ThreadLocal

看了N个贴子，ThreadLocal讲得都不是很清楚，纠缠与synchronized的区别。直到看了http://qqdwll.iteye.com/blog/685586 才清晰了ThreadLocal的作用。

 

ThreadLocal可以为每个线程维护自己的变量，对于多线程使用同一对象可以起到管理作用。

 

 

先看个例子：

 

Java代码  

1. package com.koubei.Observable;  
2.   
3. import com.sun.org.apache.xalan.internal.xsltc.compiler.sym;  
4.   
5. public class UserProcess implements Runnable{  
6.   
7.     private UserDAO userDAO;  
8.       
9.     public UserProcess(UserDAO userDAO){  
10.         this.userDAO = userDAO;  
11.     }  
12.       
13.     public  void run() {  
14.         // TODO Auto-generated method stub  
15.         for(int i=0; i<1000; i++){  
16.               
17.             userDAO.insertUser(getUser());  
18.         }  
19.     }  
20.   
21.       
22.       
23.     public static void main(String[] args) {  
24.         UserDAO userDAO = new UserDAO();  
25.           
26.         new Thread(new UserProcess(userDAO)).start();  
27.         new Thread(new UserProcess(userDAO)).start();  
28.         new Thread(new UserProcess(userDAO)).start();  
29.           
30.           
31.     }  
32. }  

 

Java代码  

1. package com.koubei.Observable;  
2.   
3. import java.sql.Connection;  
4.   
5. public class UserDAO {  
6.   
7.     private Connection conn = null;  
8.       
9.     public UserDAO(){  
10.           
11.     }  
12.       
13.     public void insertUser(User user){  
14.           
15.           getConn().prepareStatement(sql);  
16.           
17.         //jdbc 操作  
18.     }  
19.       
20.     public synchronized Connection getConn(){  
21.         if (conn == null) {  
22.             try {  
23.                 Class.forName("com.mysql.jdbc.Driver");  
24.                 CONN = DriverManager.getConnection("jdbc:mysql://"  
25.                         + DB_IP + ":" + "3306" + "/" + DB_NAME  
26.                         + "?useUnicode=true&characterEncoding=gbk", DB_USER,  
27.                         DB_PASSWORD);  
28.             } catch (Exception ex) {  
29.                 ex.printStackTrace();  
30.             }  
31.         }  
32.         return conn;  
33.     }  
34. }  

 

 

在UserProcess中多个线程引用的同一个UserDAO，在线程运行后所有的语句都是通过一个Connection执行。

 

问题：

1、多个线程使用同一个conn效率比较低，存在数据共享问题。影响效率

 

改进：

1、希望UserDAO中为每个线程开立一个conn，各线程使用自己的连接执行sql

 

改进后的代码

 

Java代码  

1. package com.koubei.Observable;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DriverManager;  
5. import java.sql.SQLException;  
6.   
7. public class UserDAO {  
8.   
9.     private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();  
10.       
11.       
12.     public UserDAO(){  
13.           
14.     }  
15.       
16.     public void insertUser(User user){  
17.           
18.         getConnection().prepareStatement(sql);  
19.           
20.         //jdbc 操作  
21.     }  
22.        
23.     public Connection getConnection(){     
24.         if (connThreadLocal.get() == null) {  
25.   
26.             Connection conn = getConn();  
27.   
28.             connThreadLocal.set(conn);  
29.   
30.             return conn;  
31.   
32.         }   
33.           
34.         return connThreadLocal.get();  
35.   
36.     }  
37.   
38.       
39.       
40.     public synchronized  Connection getConn(){  
41.         try{  
42.             Class.forName("com.mysql.jdbc.Driver");  
43.             return DriverManager.getConnection("jdbc:mysql://"  
44.                     + DB_IP + ":" + "3306" + "/" + DB_NAME  
45.                     + "?useUnicode=true&characterEncoding=gbk", DB_USER,  
46.                     DB_PASSWORD);  
47.         }cache(SQLException e){  
48.            e.printStackTrace();     
49.         }  
50.         return null;  
51.          
52.     }  
53. }  

 改动后每个线程都会维护自己的conn，userDAO变成线程安全的。

 

 synchronized 是解决多个线程访问同一个变量

 ThreadLocal 是每个线程维护自己专用的变量

 两者使用场景不一样，作用也不一样。