ThreadLocal的应用与实现原理

释放双眼,带上耳机,听听看~!

  本文对ThreadLocal的分析基于JDK 8。

本文大纲

  1. ThreadLocal快速上手
  2. ThreadLocal应用场景
  3. TheadLocal set与get方法简析
  4. TheadLocal与内存泄漏

1. ThreadLocal快速上手

  ThreadLocal是java.lang包下的一个类,它可以为每个线程维护一份独立的变量副本。当线程运行结束后,线程内部的引用的指向的实例副本都会被回收。

  对于初次接触ThreadLocal的同学来说,看了上面这段话可能还是蒙的,下面我们通过简单的例子快速上手ThreadLocal。

  我们先看看不使用ThreadLocal的情况下,让两个线程共享一个打印Task进行打印输出:

public class ThreadLocalTest1 {

    public static void main(String[] args) {
        Runnable task = new Task();
        new Thread(task, \"t1\").start();
        new Thread(task, \"t2\").start();
    }

    static class Task implements Runnable {
        Integer counter = 0; // 多个线程共享的实例

        @Override
        public void run() {
            while (true) {
                System.out.println(Thread.currentThread().getName() + \" -> \" + counter++);
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

   毫无疑问,上面这段代码对counter的操作不是线程安全的,因为counter是两个线程间共享的,所以一个线程对counter的修改操作可能会影响另一个线程对counter的输出,下面我节选了部分输出结果:

t2 -> 0
t1 -> 0 // t1线程打印0
t2 -> 1
t1 -> 2 // t1线程打印couter从0直接跳到了2,因为t0线程对counter做了修改
t2 -> 3
t1 -> 3

   可以从下图看出两个线程共享counter大致模型:

 ThreadLocal的应用与实现原理

   假设,现在有一个需求,要求t1和t2各自分别进行计数并打印,那么这时我们就可以使用ThreadLocal了,代码如下:

public class ThreadLocalTest1 {

    public static void main(String[] args) {
        Runnable task = new Task();
        new Thread(task, \"t1\").start();
        new Thread(task, \"t2\").start();
    }

    static class Task implements Runnable {
        ThreadLocal<Integer> cntTl = new ThreadLocal<Integer>() {
            protected Integer initialValue() {
                return 0; // 设置初始值为0
            }
        };

        @Override
        public void run() {
            while (true) {
                Integer counter = cntTl.get(); // 获取值
                System.out.println(Thread.currentThread().getName() + \" -> \" + counter++);
                cntTl.set(counter); // counter++后,将counter值设置回去
                try {
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

   运行上面代码的部分输出结果:

t1 -> 0
t2 -> 0
t1 -> 1
t2 -> 1
t1 -> 2
t2 -> 2
t1 -> 3
t2 -> 3

  可以看到,t1和t2两个线程分别按顺序输出了1、2、3......这就是因为上面提到过的ThreadLocal为每个线程都维护了一份数据的副本,在本例中的体现就是两个线程t1、t2中都各自有一个counter,t1和t2线程各自操作自己的counter,因此对其中一个counter的数据进行修改不会对另一个counter产生影响。

  使用ThreadLocal后的模型:

 ThreadLocal的应用与实现原理

   我们再理解深入一点,每个线程都有一个ThreadLocalMap对象,ThreadLocalMap是ThreadLocal的一个内部类:

/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null; // Thread类中的threadLocals属性

   线程t1和t2各自都有一个ThreadLocalMap对象,暂且就把它看成一个Map就行,这个Map以当前ThreadLocal对象为key,value为我们要保存的值。当使用cntTl调用get方法时,其实是以当前ThreadLocal对象为key去获取对应的value。

ThreadLocal的应用与实现原理

2. ThreadLocal应用场景

   ThreadLocal主要有如下两种应用场景:

  1. 每个线程需要单独维护一个对象实例,就像在快速上手提到的那样;

  2. 在同一线程执行的不同方法中共享对象实例。

  下面将重点分析第2种应用场景。熟悉Web开发的同学都知道MVC模型,C(Controller)会调用Service,Service调用DAO,DAO会使用Connection去连接数据库。在直接使用JDBC和数据库通信的情况下,我们需要在Service中创建Connection对象,然后打开事务,并将Connection以参数的形式传递给DAO,DAO使用Connection对象与数据库进行(开启事务的Connection和执行SQL的Connection必须是同一个),交互完成后我们在Service层进行事务的提交或者回滚。在不使用ThreadLocal的情况下,我们可能会这样写代码:

  一个SqlRunner类用于执行SQL:

public class SqlRunner {
    public void save(Connection connection, String sql, Object data) {
        System.out.println(\"sql: \" + sql + \" executed successfully\");
    }
}

  Dao调用SqlRunner:

public class Dao {
    public void save(Connection connection, Object data) { // 接收Connection
        SqlRunner sqlRunner = new SqlRunner();
        sqlRunner.save(connection, \"insert into ...\", data);
    }
}

  Service调用Dao:

public class Service {
    Dao dao = new Dao();

    public void save(Object data) {
        Connection connection = new Connection(); // 创建Connection
        connection.beginTransaction(); // 开启事务
        dao.save(connection, data); // 传入connection对象
        connection.commit(); // 提交事务
    }
}

  测试类:

public class ServiceTest {
    public static void main(String[] args) {
        Service service = new Service();
        service.save(\"test data\");
    }
}

  控制台输出:

transaction begin
data: test data, sql: insert into ... executed successfully
transaction commit

  因为开启事务的Connection和执行SQL的Connection必须是同一个,所以可以看到Service中将创建的Connection以参数的方式传给了Dao,但是这种以传参的方式共享Connection会导致每个调用Dao方法的Service都必须传递Connection,显得太不优雅,下面我们将使用ThreadLocal来改变这种局面。

  SqlRunner和上面的一样,这里不再贴出代码。

  新增一个DataSource类:

public class DataSource {
    private static ThreadLocal<Connection> tl = new ThreadLocal<>(); // 使用ThreadLocal包装Connection

    public static void beginTransaction() {
        getCurrentConnection().beginTransaction(); // 开启事务
    }

    public static void commit() {
        getCurrentConnection().commit(); // 提交事务
    }

    public static Connection getCurrentConnection() {
        Connection connection = tl.get(); // 从ThreadLocal对象tl获取connection
        if (connection == null) {
            connection = getConnection(); // 没有和当前线程绑定的connection,则新建一个
            tl.set(connection); // 将新建的connection与当前线程绑定
        }
        return connection;
    }

    private static Connection getConnection() {
        return new Connection(); // 创建线程
    }
}

  Dao:

public class Dao {
    public void save(Object data) {
        SqlRunner sqlRunner = new SqlRunner();
        Connection connection = DataSource.getCurrentConnection(); // 获取与当前线程绑定的connection
        System.out.println(\"connection in dao: \" + connection); // 打印Dao中的connection对象
        sqlRunner.save(connection, \"insert into ...\", data);
    }
}

  Service:

public class Service {
    Dao dao = new Dao();

    public void save(Object data) {
        DataSource.beginTransaction(); // 使用Connection开启事务
        dao.save(data);
        System.out.println(\"connection in dao: \" + DataSource.getCurrentConnection()); // 打印Service中connection对象
        DataSource.commit(); // 提交事务
    }
}

  测试类和上面的ServiceTest相同,这里不再贴出。

  控制台输出:

transaction begin
connection in Dao: com.andywooh.texplore.demo.concurrency.threadlocal.Connection@15db9742 data: test data, sql: insert into ... executed successfully
connection in Service: com.andywooh.texplore.demo.concurrency.threadlocal.Connection@15db9742 transaction commit

  可以看到,在Service中的connection和Dao中的Connection是同一个对象。

  简单对ThreadLocal方式在同一个线程中、不同方法间共享connection对象做一个分析:调用Service的save方法,在开启事务前会先使用DataSource的getCurrentConnection去获得一个连接,由于是第一次获取connection,此时还没有和当前线程绑定的connection对象,所以会调用getConnection方法区创建一个connection对象,并将这个connection对象和当前线程进行绑定。当在同一个线程中在Dao里再一次调用getCurrentConnection时,由于已经有一个connection和当前线程绑定,所以就会直接返回该connection对象,这样就实现了不传参但是却在Service和Dao中使用同一个Connectiond的功能。

3. TheadLocal set与get方法简析

  下面对ThreadLocal的set和get方法进行分析。再次说明一下,每个线程都包含一个ThreadLocalMap,我们先将其当成一个Map就行,ThreadLocalMap是ThreadLocal的一个内部类,这个Map中存储了我们想要和当前线程绑定的值,其中key是当前ThreadLocal对象,value是我们想要保存的值。

  set方法:

public void set(T value) {
    Thread t = Thread.currentThread(); // 获取当前线程
    ThreadLocalMap map = getMap(t); // 获取当前线程内的map
    if (map != null)
        map.set(this, value); // map不为空,则以当前ThreadLocal对象为key,value为我们想要保存的值设置到map中
    else
        createMap(t, value); // map为空,创建一个map来保存value,当然key还是当前ThreadLocal
}

  get方法:

public T get() {
    Thread t = Thread.currentThread(); // 获取当前线程
    ThreadLocalMap map = getMap(t); // 获取当前线程内的map
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this); // 以当前ThreadLocal对象为key取entry对象
        if (e != null) {
            @SuppressWarnings(\"unchecked\")
            T result = (T)e.value; // 获取entry中包装的值,也就是我们之前设置进来的value
            return result;
        }
    }
    return setInitialValue(); // map为空,创建一个map并给map设置一个初始值entry;或者map中没有entry,给已有的map添加一个初始值的entry
}

4. TheadLocal与内存泄漏

   前面提到过,当线程销毁的时候,与线程绑定的相关的对象将会被GC。下面的代码展示了Thread类中的exit方法,可以看到这里将threadLocals(就是ThreadLocalMap)进行了置空,方便虚拟机对ThreadLocalMap对象进行回收。

private void exit() {
    if (group != null) {
        group.threadTerminated(this);
        group = null;
    }
    /* Aggressively null out all reference fields: see bug 4006245 */
    target = null;
    /* Speed the release of some of these resources */
    threadLocals = null; // 把ThreadLocalMap引用置空
    inheritableThreadLocals = null;
    inheritedAccessControlContext = null;
    blocker = null;
    uncaughtExceptionHandler = null;
}

   但是在一些线程不会死亡的场景,比如在线池,因为线程不会结束,如果处理的不好,那么和线程绑定的对象就会一直存在,从而造成内存泄漏。

  因为这里涉及到强、弱引用的知识,这里简单介绍一下:我们平常写的Object obj = new Object()中的obj就是强引用,只要还有强引用指向一个对象,这个对象不会被回收。而对于弱引用,一旦发现只被弱引用引用的对象,不管当前内存空间足够与否,这个对象都会被回收。

  ThreadLocalMap中的Entry的key就是一个弱引用:

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k); // 创建一个弱引用的key
        value = v;
    }
}

  下图展示了Thread对象、ThreadLocal对象、ThreadLocalMap对象以及Entry对象之间的联系,其中虚线箭头表示Entry中的弱引用key指向了ThreadLocal对象:

ThreadLocal的应用与实现原理

  Entry对象中弱引用key指向了我们的ThreadLocal对象,当我们将ThreadLocal对象的引用置为null后,就没有强用用指向它,只剩这个弱引用指向ThreadLocal对象,那么JVM会在GC的时候回收ThreadLocal对象。然而Entry对象中value引用指向的value对象还是存活的,这样就会导致value对象一直得不到回收。但是,在我们调用ThreadLocal对象的get、set、remove方法时,会将上述提到的key为nul对应的value对象进行清除,从而避免了内存泄漏。值得注意的是,如果我们在创建一个ThreadLocal对象并set了一个value对象到ThreadLocalMap,然后不再调用前面提到的get、set、remove方法中的任意一个,此时就可能会导致这个value对象不能被回收。

给TA打赏
共{{data.count}}人
人已打赏
随笔日记

OsharpNS轻量级.net core快速开发框架简明入门教程-Osharp.Redis使用

2020-11-9 4:39:31

随笔日记

java泛型中使用的排序算法——归并排序及分析

2020-11-9 4:39:33

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索