• 0
• 0

JUC并发—12.ThreadLocal源码分析

技术分享 11个月前 (02-25) 0 999+

关注

大纲

1.ThreadLocal的特点介绍

2.ThreadLocal的使用案例

3.ThreadLocal的内部结构

4.ThreadLocal的核心方法源码

5.ThreadLocalMap的核心方法源码

6.ThreadLocalMap的原理总结

 

1.ThreadLocal的特点介绍

(1)ThreadLocal的注释说明

(2)ThreadLocal的常用方法

(3)ThreadLocal的使用案例

(4)ThreadLocal类与synchronized关键字对比

 

(1)ThreadLocal的注释说明

//This class provides thread-local variables.   //These variables differ from their normal counterparts in that  //each thread that accesses one (via its get or set method) has its own,  //independently initialized copy of the variable.  //ThreadLocal instances are typically private static fields in classes that  //wish to associate state with a thread (e.g., a user ID or Transaction ID). public class ThreadLocal<T> {     ...     ... }

ThreadLocal类可以提供线程内部的局部变量，这种变量在多线程环境下访问(通过get和set方法访问)时，能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常是private static类型，用于关联线程和线程上下文。

 

由此可知，ThreadLocal的作用是：提供线程内的局部变量，不同的线程之间不会相互干扰。由于这种变量只会在线程的生命周期内起作用，所以可以减少同一个线程内，在多个函数或者组件之间传递数据的复杂度。

 

ThreadLocal的总结如下：

一.线程并发：适用于多线程并发的场景

二.传递数据：可通过ThreadLocal在同一线程，不同组件中传递公共变量

三.线程隔离：每个线程的变量都是独立的，互相之间不会影响

 

(2)ThreadLocal的常用方法

ThreadLocal的常用方法如下：

(3)ThreadLocal的使用案例

一.没用ThreadLocal时共享变量在线程间不隔离

//需求：线程隔离 //在多线程并发的场景下, 每个线程中的变量都是相互独立 //线程A：设置(变量1) 获取(变量1) //线程B：设置(变量2) 获取(变量2) public class MyDemo {     //变量     private String content;        private String getContent() {         return content;     }        private void setContent(String content) {         this.content = content;     }        public static void main(String[] args) {         MyDemo demo = new MyDemo();         for (int i = 0; i < 5; i++) {             Thread thread = new Thread(new Runnable() {                 @Override                 public void run() {                     //每个线程: 先存一个变量, 过一会再取出这个变量                     demo.setContent(Thread.currentThread().getName() + "的数据");                     System.out.println("-----------------------");                     System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());                 }             });             thread.setName("线程" + i);             thread.start();//启动线程         }     } }

运行后打印结果如下，从结果可以看出多个线程在访问同一个变量的时候出现了异常，有些线程取出了其他线程的数据，线程之间的数据没有实现隔离。

----------------------- ----------------------- 线程0--->线程3的数据 ----------------------- ----------------------- 线程2--->线程4的数据 ----------------------- 线程4--->线程4的数据 线程3--->线程3的数据 线程1--->线程4的数据

二.使用ThreadLocal实现共享变量在线程间隔离

//需求：线程隔离 //在多线程并发的场景下, 每个线程中的变量都是相互独立 //线程A：设置(变量1) 获取(变量1) //线程B：设置(变量2) 获取(变量2) //ThreadLocal: //1.set(): 将变量绑定到当前线程中 //2.get(): 获取当前线程绑定的变量 public class MyDemo {     private static ThreadLocal<String> tl = new ThreadLocal<>();      //变量     private String content;      private String getContent() {         return tl.get();     }      private void setContent(String content) {         //变量content绑定到当前线程         tl.set(content);     }      public static void main(String[] args) {         MyDemo demo = new MyDemo();         for (int i = 0; i < 5; i++) {             Thread thread = new Thread(new Runnable() {                 @Override                 public void run() {                     demo.setContent(Thread.currentThread().getName() + "的数据");                     System.out.println("-----------------------");                     System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());                 }             });             thread.setName("线程" + i);             thread.start();//启动线程         }     } }

运行后打印结果如下，从结果看，很好地解决了多线程之间数据隔离的问题。

----------------------- 线程0--->线程0的数据 ----------------------- 线程1--->线程1的数据 ----------------------- 线程2--->线程2的数据 ----------------------- 线程3--->线程3的数据 ----------------------- 线程4--->线程4的数据

(4)ThreadLocal类与synchronized关键字对比

一.synchronized同步方式

上述线程隔离的效果完全可以通过加synchronized锁来实现。

//需求：线程隔离 //在多线程并发的场景下, 每个线程中的变量都是相互独立 //线程A：设置(变量1) 获取(变量1) //线程B：设置(变量2) 获取(变量2) public class MyDemo {     //变量     private String content;        private String getContent() {         return content;     }        private void setContent(String content) {         this.content = content;     }        public static void main(String[] args) {         MyDemo demo = new MyDemo();         for (int i = 0; i < 5; i++) {             Thread thread = new Thread(new Runnable() {                 @Override                 public void run() {                     //每个线程: 存一个变量, 过一会再取出这个变量                     synchronized (MyDemo.class){                         demo.setContent(Thread.currentThread().getName() + "的数据");                         System.out.println("-----------------------");                         System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());                     }                 }             });             thread.setName("线程" + i); //线程0~4             thread.start();         }     } }

运行后打印结果如下：

----------------------- 线程0--->线程0的数据 ----------------------- 线程1--->线程1的数据 ----------------------- 线程2--->线程2的数据 ----------------------- 线程3--->线程3的数据 ----------------------- 线程4--->线程4的数据

从结果可以发现，加锁确实可以解决这个问题。但是这里强调的是多线程数据隔离的问题，并不是多线程共享数据的问题。在这个案例中使用synchronized关键字是不合适的，降低了并发性。

 

二.ThreadLocal与synchronized的区别

虽然ThreadLocal模式与synchronized关键字，都可以用于处理多线程并发访问变量的问题，不过两者处理问题的角度和思路不同。

三.总结

虽然使用ThreadLocal和synchronized都能解决线程间数据隔离的问题，但是ThreadLocal更为合适，因为它可以使程序拥有更高的并发性。

 

2.ThreadLocal的使用案例

(1)转账案例的场景

(2)转账案例引入事务

(3)常规方案解决引入事务后的问题

(4)ThreadLocal方案解决引入事务后的问题

(5)ThreadLocal的应用场景总结

 

(1)转账案例的场景

有一个数据表account，里面有两个用户Jack和Rose，Jack给Rose转账。案例的实现使用了MySQL数据库、JDBC和C3P0框架，以下是详细的代码。

 

一.数据准备

--使用数据库 use test; --创建一张账户表 create table account(     id int primary key auto_increment,     name varchar(20),     money double ); -- 初始化数据 insert into account values(null, 'Jack', 1000); insert into account values(null, 'Rose', 0);

二.C3P0配置文件和工具类

<c3p0-config>     <!-- 使用默认的配置读取连接池对象 -->     <default-config>         <!--  连接参数 -->         <property name="driverClass">com.mysql.jdbc.Driver</property>         <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>         <property name="user">root</property>         <property name="password">123456</property>                  <!-- 连接池参数 -->         <property name="initialPoolSize">5</property>         <property name="maxPoolSize">10</property>         <property name="checkoutTimeout">3000</property>     </default-config> </c3p0-config>

三.JdbcUtils工具类

public class JdbcUtils {     //c3p0数据库连接池对象属性     private static final ComboPooledDataSource ds = new ComboPooledDataSource();          //从数据库连接池中获取一个连接     public static Connection getConnection() throws SQLException {         return ds.getConnection();     }          //释放资源     public static void release(AutoCloseable... ios) {         for (AutoCloseable io : ios) {             if (io != null) {                 try {                     io.close();                 } catch (Exception e) {                     e.printStackTrace();                 }             }         }     }                  public static void commitAndClose(Connection conn) {         try {             if (conn != null) {                 //提交事务                 conn.commit();                 //释放连接                 conn.close();             }         } catch (SQLException e) {             e.printStackTrace();         }     }          public static void rollbackAndClose(Connection conn) {         try {             if (conn != null) {                 //回滚事务                 conn.rollback();                 //释放连接                 conn.close();             }         } catch (SQLException e) {             e.printStackTrace();         }     } }

四.Dao层代码：AccountDao

public class AccountDao {     public void out(String outUser, int money) throws SQLException {         String sql = "update account set money = money - ? where name = ?";         Connection conn = JdbcUtils.getConnection();         PreparedStatement pstm = conn.prepareStatement(sql);         pstm.setInt(1,money);         pstm.setString(2,outUser);         pstm.executeUpdate();         JdbcUtils.release(pstm,conn);     }      public void in(String inUser, int money) throws SQLException {         String sql = "update account set money = money + ? where name = ?";         Connection conn = JdbcUtils.getConnection();         PreparedStatement pstm = conn.prepareStatement(sql);         pstm.setInt(1,money);         pstm.setString(2,inUser);         pstm.executeUpdate();         JdbcUtils.release(pstm,conn);     } }

五.Service层代码：AccountService

public class AccountService {     public boolean transfer(String outUser, String inUser, int money) {         AccountDao ad = new AccountDao();         try {             //转出             ad.out(outUser, money);             //转入             ad.in(inUser, money);         } catch (Exception e) {             e.printStackTrace();             return false;         }         return true;     } }

六.Web层代码：AccountWeb

public class AccountWeb {     public static void main(String[] args) {         //模拟数据 : Jack给Rose转账100         String outUser = "Jack";         String inUser = "Rose";         int money = 100;          AccountService as = new AccountService();         boolean result = as.transfer(outUser, inUser, money);          if (result == false) {             System.out.println("转账失败!");         } else {             System.out.println("转账成功!");         }     } }

(2)转账案例引入事务

案例中的转账涉及两个DML操作：一个转出，一个转入。这两个操作需要具备原子性，否则可能会出现数据修改异常。所以需要引入事务来保证转出和转入操作具备原子性，也就是要么都同时成功，要么都同时失败。

 

引入事务改造前：

public class AccountService {     public boolean transfer(String outUser, String inUser, int money) {         AccountDao ad = new AccountDao();         try {             //转出             ad.out(outUser, money);             //模拟转账过程中的异常：转出成功，转入失败             int i = 1/0;             //转入             ad.in(inUser, money);         } catch (Exception e) {             e.printStackTrace();             return false;         }         return true;     } }

引入事务改造如下：

public class AccountService {     public boolean transfer(String outUser, String inUser, int money) {         AccountDao ad = new AccountDao();         Connection conn = null;         try {             //1.开启事务             conn = JdbcUtils.getConnection();             conn.setAutoCommit(false);//禁用事务自动提交(改为手动)                          //转出             ad.out(conn, outUser, money);             //模拟转账过程中的异常：转出成功，转入失败             int i = 1/0;             //转入             ad.in(conn, inUser, money);                          //2.事务提交             JdbcUtils.commitAndClose(conn);         } catch (Exception e) {             e.printStackTrace();             //3.失败时事务回滚             JdbcUtils.rollbackAndClose(conn);             return false;         }         return true;     } }

JDBC开启事务的注意点：

为了保证所有操作在一个事务中，转账时使用的Connection必须是同一个。Service层开启事务的Connection要和Dao层访问数据库的Connection一致。线程并发情况下，每个线程只能操作各自从JdbcUtils中获取的Connection。

 

(3)常规方案解决引入事务后的问题

一.常规方案的实现

基于上面给出的前提， 常规方案是：传参 + 加锁。

传参：从Service层将Connection对象向Dao层传递

加锁：防止多个线程并发操作从JdbcUtils中获取的是同一个Connection

 

AccountService类修改如下：

//事务的使用注意点: //1.Service层和Dao层的连接对象保持一致 //2.每个线程的Connection对象必须前后一致, 线程隔离 //常规的解决方案 //1.传参: 将Service层的Connection对象直接传递到Dao层 //2.加锁: 防止多个线程并发操作从JdbcUtils中获取的同一个Connection //常规解决方案的弊端: //1.代码耦合度高 //2.降低程序性能 public class AccountService {     public boolean transfer(String outUser, String inUser, int money) {         AccountDao ad = new AccountDao();         //线程并发情况下，为了保证每个线程使用各自的Connection，避免不同的线程修改同一个Connection，故加锁         synchronized (AccountService.class) {             Connection conn = null;             try {                 //1.开启事务                 conn = JdbcUtils.getConnection();//从线程池中获取一个Connection对象                 conn.setAutoCommit(false);//禁用事务自动提交(改为手动)                                  //转出                 ad.out(conn, outUser, money);                 //模拟转账过程中的异常：转出成功，转入失败                 int i = 1/0;                 //转入                 ad.in(conn, inUser, money);                                  //2.事务提交                 JdbcUtils.commitAndClose(conn);             } catch (Exception e) {                 e.printStackTrace();                 //3.失败时事务回滚                 JdbcUtils.rollbackAndClose(conn);                 return false;             }             return true;         }     } }

AccountDao类修改如下：

注意：Connection不能在Dao层释放，否则Service层就无法使用了。

public class AccountDao {     public void out(Connection conn, String outUser, int money) throws SQLException{         String sql = "update account set money = money - ? where name = ?";         //注释从连接池获取连接的代码，使用从Service中传递过来的Connection         //Connection conn = JdbcUtils.getConnection();         PreparedStatement pstm = conn.prepareStatement(sql);         pstm.setInt(1,money);         pstm.setString(2,outUser);         pstm.executeUpdate();         //连接不能在这里释放，Service层中还需要使用         //JdbcUtils.release(pstm,conn);         JdbcUtils.release(pstm);     }      public void in(Connection conn, String inUser, int money) throws SQLException {         String sql = "update account set money = money + ? where name = ?";         //Connection conn = JdbcUtils.getConnection();         PreparedStatement pstm = conn.prepareStatement(sql);         pstm.setInt(1,money);         pstm.setString(2,inUser);         pstm.executeUpdate();         //连接不能在这里释放，Service层中还需要使用         //JdbcUtils.release(pstm,conn);         JdbcUtils.release(pstm);     } }

二.常规方案的弊端

上述的确按要求解决了问题，但是存在如下弊端：

第一.直接从Service层传递Connection到Dao层，代码耦合度比较高

第二.加锁会降低程序并发性，程序性能下降

 

(4)ThreadLocal方案解决引入事务后的问题

一.ThreadLocal方案的实现

像这种需要进行数据传递和线程隔离的场景，可以使用ThreadLocal来解决。

 

JdbcUtils工具类加入ThreadLocal：

public class JdbcUtils {     //ThreadLocal对象: 将Connection绑定在当前线程中     private static final ThreadLocal<Connection> tl = new ThreadLocal();      //c3p0数据库连接池对象属性     private static final ComboPooledDataSource ds = new ComboPooledDataSource();      //获取连接     //原来: 直接从连接池中获取连接     //现在:      //1.直接获取当前线程绑定的连接对象     //2.如果连接对象是空的，再去连接池中获取连接，并将此连接对象跟当前线程进行绑定     public static Connection getConnection() throws SQLException {         //取出当前线程绑定的connection对象         Connection conn = tl.get();         if (conn == null) {             //如果没有，则从连接池中取出             conn = ds.getConnection();             //再将connection对象绑定到当前线程中             tl.set(conn);         }         return conn;     }      //释放资源     public static void release(AutoCloseable... ios) {         for (AutoCloseable io : ios) {             if (io != null) {                 try {                     io.close();                 } catch (Exception e) {                     e.printStackTrace();                 }             }         }     }      public static void commitAndClose() {         try {             Connection conn = getConnection();             //提交事务             conn.commit();             //解除绑定             tl.remove();             //释放连接             conn.close();         } catch (SQLException e) {             e.printStackTrace();         }     }      public static void rollbackAndClose() {         try {             Connection conn = getConnection();             //回滚事务             conn.rollback();             //解除绑定             tl.remove();             //释放连接             conn.close();         } catch (SQLException e) {             e.printStackTrace();         }     } }

AccountService类不需要传递Connection对象：

public class AccountService {     public boolean transfer(String outUser, String inUser, int money) {         AccountDao ad = new AccountDao();         try {             //1.开启事务             conn = JdbcUtils.getConnection();             conn.setAutoCommit(false);//禁用事务自动提交（改为手动）                          //转出：这里不需要传参conn了             ad.out(outUser, money);             //模拟转账过程中的异常：转出成功，转入失败             int i = 1/0;             //转入             ad.in(inUser, money);                          //2.事务提交             JdbcUtils.commitAndClose(conn);         } catch (Exception e) {             e.printStackTrace();             //3.失败时事务回滚             JdbcUtils.rollbackAndClose(conn);             return false;         }         return true;     } }

AccountDao类去掉Connection参数：

public class AccountDao {     public void out(String outUser, int money) throws SQLException {         String sql = "update account set money = money - ? where name = ?";         Connection conn = JdbcUtils.getConnection();         PreparedStatement pstm = conn.prepareStatement(sql);         pstm.setInt(1,money);         pstm.setString(2,outUser);         pstm.executeUpdate();         JdbcUtils.release(pstm);     }      public void in(String inUser, int money) throws SQLException {         String sql = "update account set money = money + ? where name = ?";         Connection conn = JdbcUtils.getConnection();         PreparedStatement pstm = conn.prepareStatement(sql);         pstm.setInt(1,money);         pstm.setString(2,inUser);         pstm.executeUpdate();         JdbcUtils.release(pstm);     } }

二.ThreadLocal方案的好处

从上述可以看到，ThreadLocal方案有两个优势：

 

优势一：传递数据

保存每个线程绑定的数据，在需要的地方可以直接获取，避免参数直接传递带来的代码耦合问题。

 

优势二：线程隔离

各线程之间的数据相互隔离却又具备并发性，避免同步方式带来的性能损失。

 

(5)ThreadLocal的典型应用场景

场景一：

在TransactionSynchronizationManager类中(这是Spring-JDBC的类)，会通过ThreadLocal来保证数据库连接和事务资源的隔离性，从而避免了不同线程之间事务和连接混乱的问题。

 

场景二：

在实际开发中，当用户登录之后，拦截器会获得用户的基本信息。这些信息在后续的方法中会用到，如果设置到HttpServletRequest中，则不是很灵活，而且还依赖服务器对象，这时就可以用ThreadLocal。

 

3.ThreadLocal的内部结构

(1)早期的设计

(2)现在的设计

(3)现在的设计的优势

 

(1)早期的设计

如果不去看源码，可能会猜测ThreadLocal是如下这样设计的：

 

首先每个ThreadLocal都创建一个Map，然后用线程作为Map的key，线程的变量副本作为Map的value，这样就能让各个线程的变量副本实现数据隔离的效果。

 

这是最简单的设计方法，JDK最早期的ThreadLocal确实是这样设计的。

(2)现在的设计

JDK后面优化了设计方案，在JDK8中ThreadLocal的设计是：

 

首先让每个Thread创建一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身，value才是真正要存储的局部变量。

 

具体设计如下：

一.每个Thread线程内部都有一个Map(ThreadLocalMap)

二.Map里面存储ThreadLocal对象(key)和线程的变量副本(value)

三.Thread内部的Map由ThreadLocal维护，ThreadLocal会向Map获取和设置线程的变量副本

四.其他线程不能获取当前线程的变量副本，从而实现了数据隔离

(3)现在的设计的优势

优势一：

每个Map存储的Entry数量变少，可以降低Hash冲突发生的概率。因为之前的存储数量由Thread的数量决定，现在由ThreadLocal的数量决定。在实际中，ThreadLocal的数量往往要少于Thread的数量。

 

优势二：

当Thread销毁后，对应的ThreadLocalMap也随之销毁。让线程变量副本的生命周期跟随着线程的生命周期，可以减少内存的占用。

 

4. ThreadLocal的核心方法源码

(1)ThreadLocal的整体设计原理

(2)ThreadLocal的set()方法源码

(3)ThreadLocal的get()方法源码

(4)ThreadLocal的initialValue()方法源码

 

(1)ThreadLocal的整体设计原理

ThreadLocal为实现多个线程对同一个共享变量进行set操作时线程隔离，每个线程都有一个与ThreadLocal关联的容器来存储共享变量的初始化副本。当线程对变量副本更新时，只更新存储在当前线程关联容器中的数据副本。

 

如下图示，在每个线程中都会维护一个成员变量ThreadLocalMap。其中key是一个指向ThreadLocal实例的弱引用，而value表示ThreadLocal的初始化值或者当前线程执行set()方法设置的值。

 

假设定义了3个不同功能的ThreadLocal共享变量，而在Thread1中分别用到了这3个ThreadLocal进行操作，那么这3个ThreadLocal都会存储到Thread1的ThreadLocalMap中。

 

如果Thread2也想用这3个ThreadLocal共享变量，那么在Thread2中也会维护一个ThreadLocalMap，把这3个ThreadLocal共享变量保存到该ThreadLocalMap中。

 

如果Thread1想要对local1进行运算，则将local1实例作为key，从Thread1的ThreadLocalMap中获取对应的value值，进行运算即可。

(2)ThreadLocal的set()方法源码

该方法会在当前线程的成员变量ThreadLocalMap中设置一个值。

具体的执行流程如下：

一.首先通过Thread的currentThread()方法获取当前线程。

二.然后通过ThreadLocal的getMap()方法获取当前线程的成员变量ThreadLocalMap。

三.如果获取的ThreadLocalMap为空，于是调用createMap()方法初始化当前线程的成员变量ThreadLocalMap。

四.如果获取的ThreadLocalMap不为空，则更新ThreadLocalMap中key为当前ThreadLocal对象所对应的value。

public class ThreadLocal<T> {     ...     //在当前线程中设置一个值，并保存在该线程的ThreadLocalMap中     public void set(T value) {         //首先通过Thread.currentThread()获取当前线程         Thread t = Thread.currentThread();         //然后获取当前线程的成员变量ThreadLocalMap         ThreadLocalMap map = getMap(t);         //判断当前线程的成员变量ThreadLocalMap是否为空         if (map != null) {             //如果不为空，则调用map.set()更新ThreadLocalMap中key为当前ThreadLocal对象所对应的value             map.set(this, value);         } else {             //如果为空，则调用createMap()方法初始化当前线程的成员变量ThreadLocalMap             createMap(t, value);         }     }      //获取线程Thread的成员变量ThreadLocalMap      ThreadLocalMap getMap(Thread t) {         return t.threadLocals;     }      //初始化线程Thread的成员变量ThreadLocalMap     void createMap(Thread t, T firstValue) {         //这里的this是调用此方法的threadLocal对象         //初始化ThreadLocalMap的第一个元素，key为调用此方法的threadLocal对象，value为传入的firstValue         t.threadLocals = new ThreadLocalMap(this, firstValue);     }     ... }  public class Thread implements Runnable {     ...     //每个线程都有一个ThreadLocalMap类型的成员变量，叫threadLocals     ThreadLocal.ThreadLocalMap threadLocals = null;     ... }

(3)ThreadLocal的get()方法源码

该方法会从当前线程的成员变量ThreadLocalMap中获取一个值。

具体的执行流程如下：

一.首先通过Thread的currentThread()方法获取当前线程。

二.然后通过ThreadLocal的getMap()方法获取当前线程的成员变量ThreadLocalMap。

三.如果获取的ThreadLocalMap不为空，而且key为当前ThreadLocal对象所对应的value值也不为空，则返回该value。

四.否则就调用setInitialValue()方法，初始化当前线程的成员变量ThreadLocalMap，或者初始化ThreadLocalMap中key为当前ThreadLocal对象所对应的value值。

public class ThreadLocal<T> {     ...     //从当前线程的成员变量ThreadLocalMap中获取一个值     //如果当前线程的成员变量ThreadLocalMap为空，则调用setInitialValue()方法进行初始化     public T get() {         //获取当前线程         Thread t = Thread.currentThread();         //获取当前线程的成员变量ThreadLocalMap         ThreadLocalMap map = getMap(t);         //如果当前线程的成员变量ThreadLocalMap不为空         if (map != null) {             //以当前ThreadLocal对象为key，             //调用当前线程的成员变量ThreadLocalMap的getEntry()方法，来获取对应的Entry对象             ThreadLocalMap.Entry e = map.getEntry(this);             if (e != null) {                 @SuppressWarnings("unchecked")                 T result = (T)e.value;                 return result;             }         }                //如果当前线程的成员变量ThreadLocalMap为空，         //或者ThreadLocalMap中key为当前ThreadLocal对象所对应的value为空         //那么就需要进行初始化         return setInitialValue();     }      //进行初始化并返回key为当前ThreadLocal对象所对应的value     //该方法通过initialValue()方法获取初始值来初始化当前线程的成员变量ThreadLocalMap并赋值     //如下两种情况需要进行初始化：     //第一种情况: map不存在，表示当前线程的成员变量ThreadLocalMap还没初始化     //第二种情况: map存在, 但是key为当前ThreadLocal对象所对应的value为空     private T setInitialValue() {         //调用initialValue()方法获取初始化的值         T value = initialValue();         //获取当前线程对象         Thread t = Thread.currentThread();         //获取当前线程的成员变量ThreadLocalMap         ThreadLocalMap map = getMap(t);         //判断当前线程的成员变量ThreadLocalMap是否为空         if (map != null) {             //如果不为空，则调用map.set()更新ThreadLocalMap中key为当前ThreadLocal对象所对应的value             map.set(this, value);         } else {             //如果为空，则调用createMap()方法初始化当前线程的成员变量ThreadLocalMap             createMap(t, value);         }         //返回初始化的value         return value;     }     ... }

(4)ThreadLocal的initialValue()方法源码

在set()方法还未调用而先调用get()方法时，就会执行initialValue()方法。该方法会返回当前线程的成员变量ThreadLocalMap中，key为当前ThreadLocal对象所对应的value的初始值。initialValue()方法默认情况下会返回一个null，但可以重写覆盖此方法。

public class ThreadLocal<T> {     ...     //返回当前线程的成员变量ThreadLocalMap中，key为当前ThreadLocal对象所对应的value的初始值     protected T initialValue() {         return null;     }     ... }

5.ThreadLocalMap的核心方法源码

(1)ThreadLocalMap的初始化方法

(2)ThreadLocalMap的set()方法

(3)ThreadLocalMap的弱引用

(1)ThreadLocalMap的初始化方法

ThreadLocal的createMap()方法会初始化一个ThreadLocalMap集合。

ThreadLocalMap的构造方法主要会进行如下处理：首先初始化一个长度为16的Entry数组，然后通过对firstKey的hashCode进行位运算取模来得到一个数组下标i，接着根据firstKey和firstValue封装一个Entry对象，最后将这个Entry对象保存到Entry数组的下标为i的位置中。

public class ThreadLocal<T> {     ...     //初始化线程Thread的成员变量ThreadLocalMap     void createMap(Thread t, T firstValue) {         //这里的this是调用此方法的threadLocal对象         //初始化ThreadLocalMap的第一个元素，key为调用此方法的threadLocal对象，value为传入的firstValue         t.threadLocals = new ThreadLocalMap(this, firstValue);     }          //ThreadLocalMap is a customized hash map suitable only for maintaining thread local values.     //No operations are exported outside of the ThreadLocal class.      //The class is package private to allow declaration of fields in class Thread.     //To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.      //However, since reference queues are not used,      //stale entries are guaranteed to be removed only when the table starts running out of space.     static class ThreadLocalMap {         //The entries in this hash map extend WeakReference,          //using its main ref field as the key (which is always a ThreadLocal object).         //Note that null keys (i.e. entry.get() == null) mean that the key is no longer referenced,          //so the entry can be expunged from table.         //Such entries are referred to as "stale entries" in the code that follows.         static class Entry extends WeakReference<ThreadLocal<?>> {             //The value associated with this ThreadLocal.             Object value;             Entry(ThreadLocal<?> k, Object v) {                 super(k);                 value = v;             }         }                //The initial capacity -- MUST be a power of two.         private static final int INITIAL_CAPACITY = 16;          //The table, resized as necessary.         //table.length MUST always be a power of two.         private Entry[] table;          //The number of entries in the table.         private int size = 0;          ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {             //初始化一个长度为16的Entry数组             table = new Entry[INITIAL_CAPACITY];             //通过对firstKey这个ThreadLocal实例对象的hashCode，进行位运算取模，来得到一个数组下标i             int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);             //将firstKey和firstValue封装成一个Entry对象，保存到数组的下标为i的位置             table[i] = new Entry(firstKey, firstValue);             size = 1;             setThreshold(INITIAL_CAPACITY);         }         ...     }     ... }  public class Thread implements Runnable {     ...     //每个线程都有一个ThreadLocalMap类型的成员变量，叫threadLocals     ThreadLocal.ThreadLocalMap threadLocals = null;     ... }

(2)ThreadLocalMap的set()方法

在ThreadLocal的set()方法中，如果发现当前线程的成员变量ThreadLocalMap已经初始化了，那么就会调用ThreadLocalMap的set()方法来保存要设置的值。

在ThreadLocalMap的set(key, value)方法中，首先根据ThreadLocal对象的hashCode和数组长度进行位与运算(即取模)，来获取set()方法要设置的元素，应该放置在数组的哪个位置(即数组下标i)。

如果数组下标i的位置不存在Entry对象，则直接将key和value封装成一个新的Entry对象然后存储到数组的下标为i的这个位置。

如果数组下标i的位置存在Entry对象，则使用for循环从数组下标i位置开始往后遍历(线性探索解决Hash冲突)。

如果根据key计算出来的数组下标i已经存在其他的value，且该位置的key和要设置的key不同，则继续寻找i + 1的位置进行存储。

如果根据要设置的key找出的数组对应位置的Entry元素的key为null，则调用replaceStaleEntry()方法来进行替换和清理。

因为Entry元素中的key是弱引用，有可能ThreadLocal实例被回收了导致Entry元素中的key为null。

最后统计数组的元素个数，如果元素个数超出阈值则进行扩容。

public class ThreadLocal<T> {     ...     static class ThreadLocalMap {         //The entries in this hash map extend WeakReference,          //using its main ref field as the key (which is always a ThreadLocal object).         //Note that null keys (i.e. entry.get() == null) mean that the key is no longer referenced,          //so the entry can be expunged from table.         //Such entries are referred to as "stale entries" in the code that follows.         static class Entry extends WeakReference<ThreadLocal<?>> {             //The value associated with this ThreadLocal.             Object value;             Entry(ThreadLocal<?> k, Object v) {                 super(k);                 value = v;             }         }                //The initial capacity -- MUST be a power of two.         private static final int INITIAL_CAPACITY = 16;          //The table, resized as necessary.         //table.length MUST always be a power of two.         private Entry[] table;          //The number of entries in the table.         private int size = 0;                 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {             //初始化一个长度为16的Entry数组             table = new Entry[INITIAL_CAPACITY];             //通过对firstKey这个ThreadLocal实例对象的hashCode，进行位运算取模，来得到一个数组下标i             int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);             //将firstKey和firstValue封装成一个Entry对象，保存到数组的下标为i的位置             table[i] = new Entry(firstKey, firstValue);             size = 1;             setThreshold(INITIAL_CAPACITY);         }               //Set the value associated with key.         //@param key the thread local object         //@param value the value to be set         private void set(ThreadLocal<?> key, Object value) {             Entry[] tab = table;             int len = tab.length;             //首先根据ThreadLocal对象的hashCode和数组长度进行位与运算(即取模)，来获取元素放置的位置(即数组下标)             int i = key.threadLocalHashCode & (len-1);             //然后从i开始往后遍历到数组最后一个Entry(线性探索)             for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {                 //获取Entry元素中的key                 ThreadLocal<?> k = e.get();                 //如果key相等，则覆盖value                 if (k == key) {                     e.value = value;                     return;                 }                 //如果key为null，则用新key、value覆盖                 //同时清理key = null的陈旧数据(弱引用)                 if (k == null) {                     replaceStaleEntry(key, value, i);                     return;                 }             }                      //如果数组下标i的位置不存在数据，则直接将key和value封装成Entry对象存储到该位置             tab[i] = new Entry(key, value);             int sz = ++size;             //如果超过阈值，就需要扩容了，cleanSomeSlots()方法会清理数组中的无效的key             if (!cleanSomeSlots(i, sz) && sz >= threshold) {                 rehash();//扩容             }         }               private static int nextIndex(int i, int len) {             return ((i + 1 < len) ? i + 1 : 0);         }         ...     }     ... }

(3)ThreadLocalMap的弱引用

ThreadLocalMap的数组table中的Entry元素的key什么时候会为空？

当线程已经退出 + ThreadLocal已失去了线程的引用 + 垃圾回收时，key便会为空。也就是如果ThreadLocal对象被回收了，那么ThreadLocalMap中的key就会为空。

public class ThreadLocal<T> {     ...     static class ThreadLocalMap {         private Entry[] table;         static class Entry extends WeakReference<ThreadLocal<?>> {             //The value associated with this ThreadLocal.             Object value;             Entry(ThreadLocal<?> k, Object v) {                 super(k);                 value = v;             }         }         ...     } }

在JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。如下代码中，定义了一个Object对象和一个引用了Object对象的弱引用对象。当把object变量设置为null后，也就是object变量不再引用这个Object对象了，那么gc()方法便会对这个Object对象进行回收，尽管它被弱引用对象引用着。

public class WeakReferneceExample {     //object变量引用了新创建的Object对象     static Object object = new Object();     public static void main(String[] args) {         //objectWeakReference变量引用了新创建的WeakReference对象         //但WeakReference对象是通过传入object变量创建的，所以objectWeakReference变量其实引用了Object对象         WeakReference<Object> objectWeakReference = new WeakReference<>(object);         object = null;//object变量不再引用Object对象，但此时objectWeakReference还在引用Object对象         System.gc();//此时垃圾回收，会回收还在被弱引用引用着的Object对象         System.out.println("gc之后" + objectWeakReference.get());//会输出null     } }

如果在强引用的情况下，执行gc()方法时，Object对象是不会被回收的。

public class StrongReferenceExample {     static Object object = new Object();//object变量引用了新创建的Object对象     public static void main(String[] args) {         Object strongRef = object;//strongRef变量也引用新创建的Object对象         object = null;//object变量不再引用Object对象，但此时strongRef变量还在引用新创建的Object对象         System.gc();//此时垃圾回收，不会回收还在被强引用引用着的Object对象         System.out.println("gc之后" + strongRef);//会输出Object对象     } }

6.ThreadLocalMap的原理总结

(1)ThreadLocalMap的基本结构

(2)ThreadLocalMap的成员变量

(3)ThreadLocalMap的存储结构Entry

(4)弱引用和内存泄漏

(5)如果ThreadLocalMap的key使用强引用

(6)如果ThreadLocalMap的key使用弱引用

(7)使用ThreadLocal出现内存泄漏的原因

(8)ThreadLocalMap为什么使用弱引用

(9)使用线性探测法解决Hash冲突

(1)ThreadLocalMap的基本结构

ThreadLocalMap是ThreadLocal的内部类，它没有实现Map接口，而是用独立的方式实现了Map的功能，它内部的Entry也是用独立的方式实现的。