ThreadLocal 那点事儿(续集)

还是保持我一贯的 Style,用一个 Demo 来说话吧。用户提出一个需求:当修改产品价格的时候,需要记录操作日志,什么时候做了什么事情。

想必这个案例,只要是做过应用系统的小伙伴们,都应该遇到过吧?无外乎数据库里就两张表:product 与 log,用两条 SQL 语句应该可以解决问题:

?
1
2
update product set price = ? where id = ?
insert into log (created, description) values (?, ?)

But!要确保这两条 SQL 语句必须在同一个事务里进行提交,否则有可能 update 提交了,但 insert 却没有提交。如果这样的事情真的发生了,我们肯定会被用户指着鼻子狂骂:“为什么产品价格改了,却看不到什么时候改的呢?”。

聪明的我在接到这个需求以后,是这样做的:

首先,我写一个 DBUtil 的工具类,封装了数据库的常用操作: 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class DBUtil {
     // 数据库配置
     private static final String driver = "com.mysql.jdbc.Driver" ;
     private static final String url = "jdbc:mysql://localhost:3306/demo" ;
     private static final String username = "root" ;
     private static final String password = "root" ;
 
     // 定义一个数据库连接
     private static Connection conn = null ;
 
     // 获取连接
     public static Connection getConnection() {
         try {
             Class.forName(driver);
             conn = DriverManager.getConnection(url, username, password);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return conn;
     }
 
     // 关闭连接
     public static void closeConnection() {
         try {
             if (conn != null ) {
                 conn.close();
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
}

里面搞了一个 static 的 Connection,这下子数据库连接就好操作了,牛逼吧!

然后,我定义了一个接口,用于给逻辑层来调用:

?
1
2
3
4
public interface ProductService {
 
     void updateProductPrice( long productId, int price);
}

根据用户提出的需求,我想这个接口完全够用了。根据 productId 去更新对应 Product 的 price,然后再插入一条数据到 log 表中。

其实业务逻辑也不太复杂,于是我快速地完成了 ProductService 接口的实现类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class ProductServiceImpl implements ProductService {
 
     private static final String UPDATE_PRODUCT_SQL = "update product set price = ? where id = ?" ;
     private static final String INSERT_LOG_SQL = "insert into log (created, description) values (?, ?)" ;
 
     public void updateProductPrice( long productId, int price) {
         try {
             // 获取连接
             Connection conn = DBUtil.getConnection();
             conn.setAutoCommit( false ); // 关闭自动提交事务(开启事务)
 
             // 执行操作
             updateProduct(conn, UPDATE_PRODUCT_SQL, productId, price); // 更新产品
             insertLog(conn, INSERT_LOG_SQL, "Create product." ); // 插入日志
 
             // 提交事务
             conn.commit();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             // 关闭连接
             DBUtil.closeConnection();
         }
     }
 
     private void updateProduct(Connection conn, String updateProductSQL, long productId, int productPrice) throws Exception {
         PreparedStatement pstmt = conn.prepareStatement(updateProductSQL);
         pstmt.setInt( 1 , productPrice);
         pstmt.setLong( 2 , productId);
         int rows = pstmt.executeUpdate();
         if (rows != 0 ) {
             System.out.println( "Update product success!" );
         }
     }
 
     private void insertLog(Connection conn, String insertLogSQL, String logDescription) throws Exception {
         PreparedStatement pstmt = conn.prepareStatement(insertLogSQL);
         pstmt.setString( 1 , new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss SSS" ).format( new Date()));
         pstmt.setString( 2 , logDescription);
         int rows = pstmt.executeUpdate();
         if (rows != 0 ) {
             System.out.println( "Insert log success!" );
         }
     }
}
代码的可读性还算不错吧?这里我用到了 JDBC 的高级特性 Transaction 了。暗自庆幸了一番之后,我想是不是有必要写一个客户端,来测试一下执行结果是不是我想要的呢? 于是我偷懒,直接在 ProductServiceImpl 中增加了一个 main() 方法:
?
1
2
3
4
public static void main(String[] args) {
     ProductService productService = new ProductServiceImpl();
     productService.updateProductPrice( 1 , 3000 );
}

我想让 productId 为 1 的产品的价格修改为 3000。于是我把程序跑了一遍,控制台输出:

Update product success!
Insert log success!

应该是对了。作为一名专业的程序员,为了万无一失,我一定要到数据库里在看看。没错!product 表对应的记录更新了,log 表也插入了一条记录。这样就可以将 ProductService 接口交付给别人来调用了。

几个小时过去了,QA 妹妹开始骂我:“我靠!我才模拟了 10 个请求,你这个接口怎么就挂了?说是数据库连接关闭了!”。

听到这样的叫声,让我浑身打颤,立马中断了我的小视频,赶紧打开 IDE,找到了这个 ProductServiceImpl 这个实现类。好像没有 Bug 吧?但我现在不敢给她任何回应,我确实有点怕她的。

我突然想起,她是用工具模拟的,也就是模拟多个线程了!那我自己也可以模拟啊,于是我写了一个线程类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ClientThread extends Thread {
 
     private ProductService productService;
 
     public ClientThread(ProductService productService) {
         this .productService = productService;
     }
 
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName());
         productService.updateProductPrice( 1 , 3000 );
     }
}

我用这线程去调用 ProduceService 的方法,看看是不是有问题。此时,我还要再修改一下 main() 方法:

?
1
2
3
4
5
6
7
8
9
10
11
12
// public static void main(String[] args) {
//     ProductService productService = new ProductServiceImpl();
//     productService.updateProductPrice(1, 3000);
// }
     
public static void main(String[] args) {
     for ( int i = 0 ; i < 10 ; i++) {
         ProductService productService = new ProductServiceImpl();
         ClientThread thread = new ClientThread(productService);
         thread.start();
     }
}

我也模拟 10 个线程吧,我就不信那个邪了!

运行结果真的让我很晕、很晕:

Thread-1
Thread-3
Thread-5
Thread-7
Thread-9
Thread-0
Thread-2
Thread-4
Thread-6
Thread-8
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: No operations allowed after connection closed.
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
at com.mysql.jdbc.Util.handleNewInstance(Util.java:411)
at com.mysql.jdbc.Util.getInstance(Util.java:386)
at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1015)
at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:989)
at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:975)
at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:920)
at com.mysql.jdbc.ConnectionImpl.throwConnectionClosedException(ConnectionImpl.java:1304)
at com.mysql.jdbc.ConnectionImpl.checkClosed(ConnectionImpl.java:1296)
at com.mysql.jdbc.ConnectionImpl.commit(ConnectionImpl.java:1699)
at com.smart.sample.test.transaction.solution1.ProductServiceImpl.updateProductPrice(ProductServiceImpl.java:25)
at com.smart.sample.test.transaction.ClientThread.run(ClientThread.java:18)

我靠!竟然在多线程的环境下报错了,果然是数据库连接关闭了。怎么回事呢?我陷入了沉思中。于是我 Copy 了一把那句报错信息,在百度、Google,还有 OSC 里都找了,解答实在是千奇百怪。

我突然想起,既然是跟 Connection 有关系,那我就将主要精力放在检查 Connection 相关的代码上吧。是不是 Connection 不应该是 static 的呢?我当初设计成 static 的主要是为了让 DBUtil 的 static 方法访问起来更加方便,用 static 变量来存放 Connection 也提高了性能啊。怎么搞呢?

于是我看到了 OSC 上非常火爆的一篇文章《ThreadLocal 那点事儿》,终于才让我明白了!原来要使每个线程都拥有自己的连接,而不是共享同一个连接,否则线程1有可能会关闭线程2的连接,所以线程2就报错了。一定是这样!

我赶紧将 DBUtil 给重构了:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class DBUtil {
     // 数据库配置
     private static final String driver = "com.mysql.jdbc.Driver" ;
     private static final String url = "jdbc:mysql://localhost:3306/demo" ;
     private static final String username = "root" ;
     private static final String password = "root" ;
 
     // 定义一个用于放置数据库连接的局部线程变量(使每个线程都拥有自己的连接)
     private static ThreadLocal<Connection> connContainer = new ThreadLocal<Connection>();
 
     // 获取连接
     public static Connection getConnection() {
         Connection conn = connContainer.get();
         try {
             if (conn == null ) {
                 Class.forName(driver);
                 conn = DriverManager.getConnection(url, username, password);
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             connContainer.set(conn);
         }
         return conn;
     }
 
     // 关闭连接
     public static void closeConnection() {
         Connection conn = connContainer.get();
         try {
             if (conn != null ) {
                 conn.close();
             }
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             connContainer.remove();
         }
     }
}

我把 Connection 放到了 ThreadLocal 中,这样每个线程之间就隔离了,不会相互干扰了。

此外,在 getConnection() 方法中,首先从 ThreadLocal 中(也就是 connContainer 中) 获取 Connection,如果没有,就通过 JDBC 来创建连接,最后再把创建好的连接放入这个 ThreadLocal 中。可以把 ThreadLocal 看做是一个容器,一点不假。

同样,我也对 closeConnection() 方法做了重构,先从容器中获取 Connection,拿到了就 close 掉,最后从容器中将其 remove 掉,以保持容器的清洁。

这下应该行了吧?我再次运行 main() 方法:

Thread-0
Thread-2
Thread-4
Thread-6
Thread-8
Thread-1
Thread-3
Thread-5
Thread-7
Thread-9
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!
Update product success!
Insert log success!

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: ThreadLocal 是 Java 中的一个类,可以为每个线程绑定一个特定的变量,这样每个线程就可以访问自己绑定的变量了。使用时有一些注意点: 1. 不要将 ThreadLocal 的实例定义为 static 变量,因为这样会导致所有线程共享同一个变量,而不是每个线程都有自己的变量。 2. 在线程使用完 ThreadLocal 变量之后,一定要记得调用 remove() 方法清除线程的变量副本,因为如果不清除,线程池回收线程时,ThreadLocal 实例变量可能无法被回收,导致内存泄漏。 3. 在使用 ThreadLocal 的过程中,一定要注意线程安全问题。 4. 如果使用的是继承自 ThreadLocal 的匿名内部类,要注意内存泄漏的问题。 希望这些信息对你有帮助。 ### 回答2: ThreadLocal 是一个用于线程私有变量的类。它可以在多线程环境下确保每个线程都拥有独立的变量副本,避免了线程之间的数据共享和竞争。 使用 ThreadLocal 需要注意以下几点: 1. 避免内存泄漏:使用 ThreadLocal 时,要注意及时清理线程中的变量副本,避免长时间持有变量导致内存泄漏。 2. 初始值的设置:ThreadLocal 变量需要设置初始值,确保每个线程首次访问变量时能够获得正确的初始值。可以通过重写 ThreadLocal 的 initialValue() 方法来设置初始值。 3. 线程复用的问题:在线程池等线程复用的场景下,要注意 ThreadLocal 变量在线程复用时可能会引起数据污染的问题,需要在每次使用 ThreadLocal 变量之前,通过 remove() 方法将变量副本清除,保证线程复用时变量的独立性。 4. 变量的线程安全性:尽管 ThreadLocal 可以保证每个线程有独立的变量副本,但是,如果被存储在 ThreadLocal 中的变量本身不是线程安全的,仍然可能出现线程安全问题。因此,要注意保证存储在 ThreadLocal 中的变量的线程安全性。 5. 变量的传递问题:由于 ThreadLocal 变量只能在当前线程内共享,因此在不同线程之间传递数据需要通过其他方式,例如,可以利用线程池的 ThreadLocalMap 来实现传递。 总之,使用 ThreadLocal 时,要注意清理变量副本、设置初始值、处理线程复用、保证变量的线程安全性以及解决变量传递问题,以确保正常使用并避免潜在的问题。 ### 回答3: ThreadLocal 是一个 Java 中的线程局部变量,它提供了线程内的共享变量,在多线程环境下可以保证每个线程都拥有自己独立的变量副本,互不干扰。在使用 ThreadLocal 时需要注意以下几点: 1. 内存泄漏问题:使用 ThreadLocal 时需要小心内存泄漏问题。由于 ThreadLocal 中的变量是每个线程独立的,如果没有及时清理 ThreadLocal 对应的变量,可能会导致长时间不使用的线程仍然存在于内存中,造成内存泄漏。因此,在使用完 ThreadLocal 后应该显式地调用 remove() 方法清理对应的变量。 2. 初始化问题:ThreadLocal 变量的初始化是在每个线程中进行的,因此每个线程都会有一个对应的初始化值。在使用 ThreadLocal 时需要关注初始化值是否满足业务需求,否则可能会导致错误的结果。 3. 无法共享数据:虽然 ThreadLocal 在每个线程中都可以独立使用变量,但是无法实现线程间的数据共享。如果需要线程间的数据传递或共享,应该使用其他方式,如使用共享变量或传递参数等。 4. 线程重用问题:在线程重用的场景中,例如线程池,由于线程对象被复用,ThreadLocal 中的变量可能会被上一次使用的线程遗留下来,导致出现错误的结果。因此,在使用线程池等重用线程的情况下,需要特别小心 ThreadLocal 的使用。 总之,ThreadLocal 是一个非常有用的工具,能够解决线程间的变量共享问题。但是在使用时需要注意内存泄漏问题、初始化问题、无法共享数据和线程重用问题,以确保程序的正确性和性能。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值