首页 > 代码库 > ThreadLocal类深刻理解
ThreadLocal类深刻理解
synchronized这类线程同步的机制可以解决多线程并发问题,在这种解决方案下,多个线程访问到的,都是同一份变量的内容。为了防止在多线程访问的过程中,可能会出现的并发错误。不得不对多个线程的访问进行同步,这样也就意味着,多个线程必须先后对变量的值进行访问或者修改,这是一种以延长访问时间来换取线程安全性的策略。
而ThreadLocal类为每一个线程都维护了自己独有的变量拷贝。每个线程都拥有了自己独立的一个变量,竞争条件被彻底消除了,那就没有任何必要对这些线程进行同步,它们也能最大限度的由CPU调度,并发执行。并且由于每个线程在访问该变量时,读取和修改的,都是自己独有的那一份变量拷贝,变量被彻底封闭在每个访问的线程中,并发错误出现的可能也完全消除了。对比前一种方案,这是一种以空间来换取线程安全性的策略。
主要方法如下:
try {
// 通过默认配置文件hibernate.cfg.xml创建SessionFactory
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
log.error("初始化SessionFactory失败!", ex);
throw new ExceptionInInitializerError(ex);
}
}
//创建线程局部变量session,用来保存Hibernate的Session
public static final ThreadLocal session = new ThreadLocal();
* 获取当前线程中的Session
* @return Session
* @throws HibernateException
*/
public static Session currentSession() throws HibernateException {
Session s = (Session) session.get();
// 如果Session还没有打开,则新开一个Session
if (s == null) {
s = sessionFactory.openSession();
session.set(s); //将新开的Session保存到线程局部变量中
}
return s;
}
//获取线程局部变量,并强制转换为Session类型
Session s = (Session) session.get();
session.set(null);
if (s != null)
s.close();
}
}
* 学生
*/
public class Student {
private int age = 0; //年龄
return this.age;
}
this.age = age;
}
}
* 多线程下测试程序
*/
public class ThreadLocalDemo implements Runnable {
//创建线程局部变量studentLocal,在后面你会发现用来保存Student对象
private final static ThreadLocal studentLocal = new ThreadLocal();
ThreadLocalDemo td = new ThreadLocalDemo();
Thread t1 = new Thread(td, "a");
Thread t2 = new Thread(td, "b");
t1.start();
t2.start();
}
accessStudent();
}
* 示例业务方法,用来测试
*/
public void accessStudent() {
//获取当前线程的名字
String currentThreadName = Thread.currentThread().getName();
System.out.println(currentThreadName + " is running!");
Random random = new Random();
int age = random.nextInt(100);
System.out.println("thread " + currentThreadName + " set age to:" + age);
Student student = getStudent();
student.setAge(age);
System.out.println("thread " + currentThreadName + " first read age is:" + student.getAge());
try {
Thread.sleep(500);
}
catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("thread " + currentThreadName + " second read age is:" + student.getAge());
}
//获取本地线程变量并强制转换为Student类型
Student student = (Student) studentLocal.get();
//线程首次执行此方法的时候,studentLocal.get()肯定为null
if (student == null) {
//创建一个Student对象,并保存到本地线程变量studentLocal中
student = new Student();
studentLocal.set(student);
}
return student;
}
}
thread a set age to:76
b is running!
thread b set age to:27
thread a first read age is:76
thread b first read age is:27
thread a second read age is:76
thread b second read age is:27
3、数据库连接管理
public class ConnectionManager { |
06 |
07 | private static ThreadLocal<Connection> connectionHolder = new ThreadLocal<Connection>() { |
08 | @Override |
09 | protected Connection initialValue() { |
10 | Connection conn = null ; |
11 | try { |
12 | conn = DriverManager.getConnection( |
13 | "jdbc:mysql://localhost:3306/test" , "username" , |
14 | "password" ); |
15 | } catch (SQLException e) { |
16 | e.printStackTrace(); |
17 | } |
18 | return conn; |
19 | } |
20 | }; |
21 |
22 | public static Connection getConnection() { |
23 | return connectionHolder.get(); |
24 | } |
25 |
26 | public static void setConnection(Connection conn) { |
27 | connectionHolder.set(conn); |
28 | } |
29 | } |
知其所以然
那么到底ThreadLocal类是如何实现这种“为每个线程提供不同的变量拷贝”的呢?先来看一下ThreadLocal的set()方法的源码是如何实现的:
01 | /** |
02 | * Sets the current thread‘s copy of this thread-local variable |
03 | * to the specified value. Most subclasses will have no need to |
04 | * override this method, relying solely on the {@link #initialValue} |
05 | * method to set the values of thread-locals. |
06 | * |
07 | * @param value the value to be stored in the current thread‘s copy of |
08 | * this thread-local. |
09 | */ |
10 | public void set(T value) { |
11 | Thread t = Thread.currentThread(); |
12 | ThreadLocalMap map = getMap(t); |
13 | if (map != null ) |
14 | map.set( this , value); |
15 | else |
16 | createMap(t, value); |
17 | } |
没有什么魔法,在这个方法内部我们看到,首先通过getMap(Thread t)方法获取一个和当前线程相关的ThreadLocalMap,然后将变量的值设置到这个ThreadLocalMap对象中,当然如果获取到的ThreadLocalMap对象为空,就通过createMap方法创建。
线程隔离的秘密,就在于ThreadLocalMap这个类。ThreadLocalMap是ThreadLocal类的一个静态内部类,它实现了键值对的设置和获取(对比Map对象来理解),每个线程中都有一个独立的ThreadLocalMap副本,它所存储的值,只能被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本,从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自己特有的,完全不会有并发错误。还有一点就是,ThreadLocalMap存储的键值对中的键是this对象指向的ThreadLocal对象,而值就是你所设置的对象了。
为了加深理解,我们接着看上面代码中出现的getMap和createMap方法的实现:
1 | ThreadLocalMap getMap(Thread t) { |
2 | return t.threadLocals; |
3 | } |
1 | void createMap(Thread t, T firstValue) { |
2 | t.threadLocals = new ThreadLocalMap( this , firstValue); |
3 | } |
代码已经说的非常直白,就是获取和设置Thread内的一个叫threadLocals的变量,而这个变量的类型就是ThreadLocalMap,这样进一步验证了上文中的观点:每个线程都有自己独立的ThreadLocalMap对象。打开java.lang.Thread类的源代码,我们能得到更直观的证明:
1 | /* ThreadLocal values pertaining to this thread. This map is maintained |
2 | * by the ThreadLocal class. */ |
3 | ThreadLocal.ThreadLocalMap threadLocals = null ; |
那么接下来再看一下ThreadLocal类中的get()方法,代码是这么说的:
01 | /** |
02 | * Returns the value in the current thread‘s copy of this |
03 | * thread-local variable. If the variable has no value for the |
04 | * current thread, it is first initialized to the value returned |
05 | * by an invocation of the {@link #initialValue} method. |
06 | * |
07 | * @return the current thread‘s value of this thread-local |
08 | */ |
09 | public T get() { |
10 | Thread t = Thread.currentThread(); |
11 | ThreadLocalMap map = getMap(t); |
12 | if (map != null ) { |
13 | ThreadLocalMap.Entry e = map.getEntry( this ); |
14 | if (e != null ) |
15 | return (T)e.value; |
16 | } |
17 | return setInitialValue(); |
18 | } |
19 |
20 | /** |
21 | * Variant of set() to establish initialValue. Used instead |
22 | * of set() in case user has overridden the set() method. |
23 | * |
24 | * @return the initial value |
25 | */ |
26 | private T setInitialValue() { |
27 | T value = http://www.mamicode.com/initialValue(); |
28 | Thread t = Thread.currentThread(); |
29 | ThreadLocalMap map = getMap(t); |
30 | if (map != null ) |
31 | map.set( this , value); |
32 | else |
33 | createMap(t, value); |
34 | return value; |
35 | } |
这两个方法的代码告诉我们,在获取和当前线程绑定的值时,ThreadLocalMap对象是以this指向的ThreadLocal对象为键进行查找的,这当然和前面set()方法的代码是相呼应的。
进一步地,我们可以创建不同的ThreadLocal实例来实现多个变量在不同线程间的访问隔离,为什么可以这么做?因为不同的ThreadLocal对象作为不同键,当然也可以在线程的ThreadLocalMap对象中设置不同的值了。通过ThreadLocal对象,在多线程中共享一个值和多个值的区别,就像你在一个HashMap对象中存储一个键值对和多个键值对一样,仅此而已。
设置到这些线程中的隔离变量,会不会导致内存泄漏呢?ThreadLocalMap对象保存在Thread对象中,当某个线程终止后,存储在其中的线程隔离的变量,也将作为Thread实例的垃圾被回收掉,所以完全不用担心内存泄漏的问题。在多个线程中隔离的变量,光荣的生,合理的死,真是圆满,不是么?
最后再提一句,ThreadLocal变量的这种隔离策略,也不是任何情况下都能使用的。如果多个线程并发访问的对象实例只允许,也只能创建那么一个,那就没有别的办法了,老老实实的使用同步机制来访问吧。
总结:
ThreadLocal使用的一般步骤