Java多线程编程中ThreadLocal类的用法及深入
ThreadLocal，直译为“线程本地”或“本地线程”，如果你真的这么认为，那就错了！其实，它就是一个容器，用于存放线程的局部变量，我认为应该叫做ThreadLocalVariable（线程局部变量）才对，真不理解为什么当初Sun公司的工程师这样命名。
早在JDK1.2的时代，java.lang.ThreadLocal就诞生了，它是为了解决多线程并发问题而设计的，只不过设计得有些难用，所以至今没有得到广泛使用。其实它还是挺有用的，不相信的话，我们一起来看看这个例子吧。
一个序列号生成器的程序，可能同时会有多个线程并发访问它，要保证每个线程得到的序列号都是自增的，而不能相互干扰。
先定义一个接口：
publicinterfaceSequence{
intgetNumber();
}
每次调用getNumber()方法可获取一个序列号，下次再调用时，序列号会自增。
再做一个线程类：
publicclassClientThreadextendsThread{
privateSequencesequence;
publicClientThread(Sequencesequence){
this.sequence=sequence;
}
@Override
publicvoidrun(){
for(inti=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+"=>"+sequence.getNumber());
}
}
}
在线程中连续输出三次线程名与其对应的序列号。
我们先不用ThreadLocal，来做一个实现类吧。
publicclassSequenceAimplementsSequence{
privatestaticintnumber=0;
publicintgetNumber(){
number=number+1;
returnnumber;
}
publicstaticvoidmain(String[]args){
Sequencesequence=newSequenceA();
ClientThreadthread1=newClientThread(sequence);
ClientThreadthread2=newClientThread(sequence);
ClientThreadthread3=newClientThread(sequence);
thread1.start();
thread2.start();
thread3.start();
}
}
序列号初始值是0，在main()方法中模拟了三个线程，运行后结果如下：
Thread-0=>1 Thread-0=>2 Thread-0=>3 Thread-2=>4 Thread-2=>5 Thread-2=>6 Thread-1=>7 Thread-1=>8 Thread-1=>9
由于线程启动顺序是随机的，所以并不是0、1、2这样的顺序，这个好理解。为什么当Thread-0输出了1、2、3之后，而Thread-2却输出了4、5、6呢？线程之间竟然共享了static变量！这就是所谓的“非线程安全”问题了。
那么如何来保证“线程安全”呢？对应于这个案例，就是说不同的线程可拥有自己的static变量，如何实现呢？下面看看另外一个实现吧。
publicclassSequenceBimplementsSequence{
privatestaticThreadLocal<Integer>numberContainer=newThreadLocal<Integer>(){
@Override
protectedIntegerinitialValue(){
return0;
}
};
publicintgetNumber(){
numberContainer.set(numberContainer.get()+1);
returnnumberContainer.get();
}
publicstaticvoidmain(String[]args){
Sequencesequence=newSequenceB();
ClientThreadthread1=newClientThread(sequence);
ClientThreadthread2=newClientThread(sequence);
ClientThreadthread3=newClientThread(sequence);
thread1.start();
thread2.start();
thread3.start();
}
}
通过ThreadLocal封装了一个Integer类型的numberContainer静态成员变量，并且初始值是0。再看getNumber()方法，首先从numberContainer中get出当前的值，加1，随后set到numberContainer中，最后将numberContainer中get出当前的值并返回。
是不是很恶心？但是很强大！确实稍微饶了一下，我们不妨把ThreadLocal看成是一个容器，这样理解就简单了。所以，这里故意用Container这个单词作为后缀来命名ThreadLocal变量。
运行结果如何呢？看看吧。
Thread-0=>1 Thread-0=>2 Thread-0=>3 Thread-2=>1 Thread-2=>2 Thread-2=>3 Thread-1=>1 Thread-1=>2 Thread-1=>3
每个线程相互独立了，同样是static变量，对于不同的线程而言，它没有被共享，而是每个线程各一份，这样也就保证了线程安全。也就是说，TheadLocal为每一个线程提供了一个独立的副本！
搞清楚ThreadLocal的原理之后，有必要总结一下ThreadLocal的API，其实很简单。
- publicvoidset(Tvalue)：将值放入线程局部变量中
- publicTget()：从线程局部变量中获取值
- publicvoidremove()：从线程局部变量中移除值（有助于JVM垃圾回收）
- protectedTinitialValue()：返回线程局部变量中的初始值（默认为null）
为什么initialValue()方法是protected的呢？就是为了提醒程序员们，这个方法是要你们来实现的，请给这个线程局部变量一个初始值吧。
了解了原理与这些API，其实想想ThreadLocal里面不就是封装了一个Map吗？自己都可以写一个ThreadLocal了，尝试一下吧。
publicclassMyThreadLocal<T>{
privateMap<Thread,T>container=Collections.synchronizedMap(newHashMap<Thread,T>());
publicvoidset(Tvalue){
container.put(Thread.currentThread(),value);
}
publicTget(){
Threadthread=Thread.currentThread();
Tvalue=container.get(thread);
if(value==null&&!container.containsKey(thread)){
value=initialValue();
container.put(thread,value);
}
returnvalue;
}
publicvoidremove(){
container.remove(Thread.currentThread());
}
protectedTinitialValue(){
returnnull;
}
}
以上完全山寨了一个ThreadLocal，其中中定义了一个同步Map（为什么要这样？请读者自行思考），代码应该非常容易读懂。
下面用这MyThreadLocal再来实现一把看看。
publicclassSequenceCimplementsSequence{
privatestaticMyThreadLocal<Integer>numberContainer=newMyThreadLocal<Integer>(){
@Override
protectedIntegerinitialValue(){
return0;
}
};
publicintgetNumber(){
numberContainer.set(numberContainer.get()+1);
returnnumberContainer.get();
}
publicstaticvoidmain(String[]args){
Sequencesequence=newSequenceC();
ClientThreadthread1=newClientThread(sequence);
ClientThreadthread2=newClientThread(sequence);
ClientThreadthread3=newClientThread(sequence);
thread1.start();
thread2.start();
thread3.start();
}
}
以上代码其实就是将ThreadLocal替换成了MyThreadLocal，仅此而已，运行效果和之前的一样，也是正确的。
其实ThreadLocal可以单独成为一种设计模式，就看你怎么看了。
ThreadLocal具体有哪些使用案例呢？
我想首先要说的就是：通过ThreadLocal存放JDBCConnection，以达到事务控制的能力。
还是保持我一贯的Style，用一个Demo来说话吧。用户提出一个需求：当修改产品价格的时候，需要记录操作日志，什么时候做了什么事情。
想必这个案例，只要是做过应用系统的小伙伴们，都应该遇到过吧？无外乎数据库里就两张表：product与log，用两条SQL语句应该可以解决问题：
updateproductsetprice=?whereid=? insertintolog(created,description)values(?,?)
But！要确保这两条SQL语句必须在同一个事务里进行提交，否则有可能update提交了，但insert却没有提交。如果这样的事情真的发生了，我们肯定会被用户指着鼻子狂骂：“为什么产品价格改了，却看不到什么时候改的呢？”。
聪明的我在接到这个需求以后，是这样做的：
首先，我写一个DBUtil的工具类，封装了数据库的常用操作：
publicclassDBUtil{
//数据库配置
privatestaticfinalStringdriver="com.mysql.jdbc.Driver";
privatestaticfinalStringurl="jdbc:mysql://localhost:3306/demo";
privatestaticfinalStringusername="root";
privatestaticfinalStringpassword="root";
//定义一个数据库连接
privatestaticConnectionconn=null;
//获取连接
publicstaticConnectiongetConnection(){
try{
Class.forName(driver);
conn=DriverManager.getConnection(url,username,password);
}catch(Exceptione){
e.printStackTrace();
}
returnconn;
}
//关闭连接
publicstaticvoidcloseConnection(){
try{
if(conn!=null){
conn.close();
}
}catch(Exceptione){
e.printStackTrace();
}
}
}
里面搞了一个static的Connection，这下子数据库连接就好操作了，牛逼吧！
然后，我定义了一个接口，用于给逻辑层来调用：
publicinterfaceProductService{
voidupdateProductPrice(longproductId,intprice);
}
根据用户提出的需求，我想这个接口完全够用了。根据productId去更新对应Product的price，然后再插入一条数据到log表中。
其实业务逻辑也不太复杂，于是我快速地完成了ProductService接口的实现类：
publicclassProductServiceImplimplementsProductService{
privatestaticfinalStringUPDATE_PRODUCT_SQL="updateproductsetprice=?whereid=?";
privatestaticfinalStringINSERT_LOG_SQL="insertintolog(created,description)values(?,?)";
publicvoidupdateProductPrice(longproductId,intprice){
try{
//获取连接
Connectionconn=DBUtil.getConnection();
conn.setAutoCommit(false);//关闭自动提交事务（开启事务）
//执行操作
updateProduct(conn,UPDATE_PRODUCT_SQL,productId,price);//更新产品
insertLog(conn,INSERT_LOG_SQL,"Createproduct.");//插入日志
//提交事务
conn.commit();
}catch(Exceptione){
e.printStackTrace();
}finally{
//关闭连接
DBUtil.closeConnection();
}
}
privatevoidupdateProduct(Connectionconn,StringupdateProductSQL,longproductId,intproductPrice)throwsException{
PreparedStatementpstmt=conn.prepareStatement(updateProductSQL);
pstmt.setInt(1,productPrice);
pstmt.setLong(2,productId);
introws=pstmt.executeUpdate();
if(rows!=0){
System.out.println("Updateproductsuccess!");
}
}
privatevoidinsertLog(Connectionconn,StringinsertLogSQL,StringlogDescription)throwsException{
PreparedStatementpstmt=conn.prepareStatement(insertLogSQL);
pstmt.setString(1,newSimpleDateFormat("yyyy-MM-ddHH:mm:ssSSS").format(newDate()));
pstmt.setString(2,logDescription);
introws=pstmt.executeUpdate();
if(rows!=0){
System.out.println("Insertlogsuccess!");
}
}
}
代码的可读性还算不错吧？这里我用到了JDBC的高级特性Transaction了。暗自庆幸了一番之后，我想是不是有必要写一个客户端，来测试一下执行结果是不是我想要的呢？于是我偷懒，直接在ProductServiceImpl中增加了一个main()方法：
publicstaticvoidmain(String[]args){
ProductServiceproductService=newProductServiceImpl();
productService.updateProductPrice(1,3000);
}
我想让productId为1的产品的价格修改为3000。于是我把程序跑了一遍，控制台输出：
Updateproductsuccess! Insertlogsuccess!
应该是对了。作为一名专业的程序员，为了万无一失，我一定要到数据库里在看看。没错！product表对应的记录更新了，log表也插入了一条记录。这样就可以将ProductService接口交付给别人来调用了。
几个小时过去了，QA妹妹开始骂我：“我靠！我才模拟了10个请求，你这个接口怎么就挂了？说是数据库连接关闭了！”。
听到这样的叫声，让我浑身打颤，立马中断了我的小视频，赶紧打开IDE，找到了这个ProductServiceImpl这个实现类。好像没有Bug吧？但我现在不敢给她任何回应，我确实有点怕她的。
我突然想起，她是用工具模拟的，也就是模拟多个线程了！那我自己也可以模拟啊，于是我写了一个线程类：
publicclassClientThreadextendsThread{
privateProductServiceproductService;
publicClientThread(ProductServiceproductService){
this.productService=productService;
}
@Override
publicvoidrun(){
System.out.println(Thread.currentThread().getName());
productService.updateProductPrice(1,3000);
}
}
我用这线程去调用ProduceService的方法，看看是不是有问题。此时，我还要再修改一下main()方法：
//publicstaticvoidmain(String[]args){
//ProductServiceproductService=newProductServiceImpl();
//productService.updateProductPrice(1,3000);
//}
publicstaticvoidmain(String[]args){
for(inti=0;i<10;i++){
ProductServiceproductService=newProductServiceImpl();
ClientThreadthread=newClientThread(productService);
thread.start();
}
}
我也模拟10个线程吧，我就不信那个邪了！
运行结果真的让我很晕、很晕：
Thread-1 Thread-3 Thread-5 Thread-7 Thread-9 Thread-0 Thread-2 Thread-4 Thread-6 Thread-8 Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException:Nooperationsallowedafterconnectionclosed. atsun.reflect.NativeConstructorAccessorImpl.newInstance0(NativeMethod) atsun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39) atsun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27) atjava.lang.reflect.Constructor.newInstance(Constructor.java:513) atcom.mysql.jdbc.Util.handleNewInstance(Util.java:411) atcom.mysql.jdbc.Util.getInstance(Util.java:386) atcom.mysql.jdbc.SQLError.createSQLException(SQLError.java:1015) atcom.mysql.jdbc.SQLError.createSQLException(SQLError.java:989) atcom.mysql.jdbc.SQLError.createSQLException(SQLError.java:975) atcom.mysql.jdbc.SQLError.createSQLException(SQLError.java:920) atcom.mysql.jdbc.ConnectionImpl.throwConnectionClosedException(ConnectionImpl.java:1304) atcom.mysql.jdbc.ConnectionImpl.checkClosed(ConnectionImpl.java:1296) atcom.mysql.jdbc.ConnectionImpl.commit(ConnectionImpl.java:1699) atcom.smart.sample.test.transaction.solution1.ProductServiceImpl.updateProductPrice(ProductServiceImpl.java:25) atcom.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给重构了：
publicclassDBUtil{
//数据库配置
privatestaticfinalStringdriver="com.mysql.jdbc.Driver";
privatestaticfinalStringurl="jdbc:mysql://localhost:3306/demo";
privatestaticfinalStringusername="root";
privatestaticfinalStringpassword="root";
//定义一个用于放置数据库连接的局部线程变量（使每个线程都拥有自己的连接）
privatestaticThreadLocal<Connection>connContainer=newThreadLocal<Connection>();
//获取连接
publicstaticConnectiongetConnection(){
Connectionconn=connContainer.get();
try{
if(conn==null){
Class.forName(driver);
conn=DriverManager.getConnection(url,username,password);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
connContainer.set(conn);
}
returnconn;
}
//关闭连接
publicstaticvoidcloseConnection(){
Connectionconn=connContainer.get();
try{
if(conn!=null){
conn.close();
}
}catch(Exceptione){
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 Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess! Updateproductsuccess! Insertlogsuccess!
总算是解决了