`
linliangyi2007
  • 浏览: 1004582 次
  • 性别: Icon_minigender_1
  • 来自: 福州
社区版块
存档分类
最新评论

简明扼要，再谈ThreadLocal和synchronized

threadJVM框架 
阅读更多
    昨天上Java版块逛了一圈，一个2万5千人浏览的帖子引起了偶滴注意 ThreadLocal与synchronized ，9页以上的回复，足见大家对这个问题的兴趣。

     老实说，从看到这个帖子的题目开始，就觉得帖子的作者估计是在概念上有所混淆了,于是乎想写个咚咚，同大家分享一下自己的心得。

     帖子上，讨论的人很多，高手不乏，各抒己见，但不知新手们看明白没有，因此，这里偶以最简洁列表方式来说一说相关问题。

1．区别ThreadLocal 与 synchronized
  • ThreadLocal是一个线程隔离(或者说是线程安全)的变量存储的管理实体（注意：不是存储用的），它以Java类方式表现；
  • synchronized是Java的一个保留字，只是一个代码标识符，它依靠JVM的锁机制来实现临界区的函数、变量在CPU运行访问中的原子性。
两者的性质、表现及设计初衷不同，因此没有可比较性。

2.理解ThreadLocal中提到的变量副本
    事实上，我们向ThreadLocal中set的变量不是由ThreadLocal来存储的，而是Thread线程对象自身保存。当用户调用ThreadLocal对象的set(Object o)时，该方法则通过Thread.currentThread()获取当前线程，将变量存入Thread中的一个Map内，而Map的Key就是当前的ThreadLocal实例。请看源码，这是最主要的两个函数，能看出ThreadLocal与Thread的调用关系： 
public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}

（有兴趣的朋友可以阅读Java的ThreadLocal源码）因此，我们可以知道，所谓的变量副本，即是对Object Reference（对象引用）的拷贝。

3.理解Thread和 ThreadLocal对变量的引用关系
    实际上Thread和ThreadLocal对变量引用关系就像是坐标系中的X轴和Y轴，是从两个维度上来组织对变量的引用的。
  • 首先说Thread。
    •     我们知道一个ThreadOne的执行会贯穿多个方法MethodA、MethodB、MethodC这些方法可能分布于不同的类实例。假设，这些方法分别使用了ThreadLocalA、ThreadLocalB、ThreadLocalC来保存线程本地变量，那么这些变量都存于ThreadOne的Map中，并使用各自的ThreadLocal实例作为key。 因此，可以认为，借助ThreanLocal的set方法，在X轴上，Thread横向关联同一线程上下文中来自多个Method的变量引用副本。



  • 接着说ThreadLocal。
    •     一个MethodA中的X变量将被多个线程ThreadOne、ThreadTwo、ThreadThree所访问。假设MethodA使用ThreadLocal存储X，通过set方法，以ThreadLocal作为key值，将不同线程来访时的不同的变量值引用保存于ThreadOne、ThreadTwo、ThreadThree的各自线程上下文中，确保每个线程有自己的一个变量值。因此，可以认为，ThreadLocal是以Method为Y轴，纵向关联了处于同一方法中的不同线程上的变量。



希望能对大家有所帮助，这样可以少走很多弯路哦。







分享到：
| 很“水产”的史前一万年
评论
21 楼 ariestiger 2012-12-25  
ThreadLocal只是一个key，不同的Thread可以通过这个key拿到不同的值（其实这值都存放在该Thread中），看看ThreadLocal中get, set方法就全清楚了。
20 楼 jeffmacn 2011-08-18  
每个线程一个拷贝，那这个拷贝工作是何时在哪做的？源代码在哪？
19 楼 jzhua2006 2009-01-13  
linliangyi2007 写道
    昨天上Java版块逛了一圈，一个2万5千人浏览的帖子引起了偶滴注意 ThreadLocal与synchronized ，9页以上的回复，足见大家对这个问题的兴趣。

     老实说，从看到这个帖子的题目开始，就觉得帖子的作者估计是在概念上有所混淆了,于是乎想写个咚咚，同大家分享一下自己的心得。

     帖子上，讨论的人很多，高手不乏，各抒己见，但不知新手们看明白没有，因此，这里偶以最简洁列表方式来说一说相关问题。

1．区别ThreadLocal 与 synchronized
  • ThreadLocal是一个线程隔离(或者说是线程安全)的变量存储的管理实体（注意：不是存储用的），它以Java类方式表现；
  • synchronized是Java的一个保留字，只是一个代码标识符，它依靠JVM的锁机制来实现临界区的函数、变量在CPU运行访问中的原子性。
两者的性质、表现及设计初衷不同，因此没有可比较性。

2.理解ThreadLocal中提到的变量副本
    事实上，我们向ThreadLocal中set的变量不是由ThreadLocal来存储的，而是Thread线程对象自身保存。当用户调用ThreadLocal对象的set(Object o)时，该方法则通过Thread.currentThread()获取当前线程，将变量存入Thread中的一个Map内，而Map的Key就是当前的ThreadLocal实例。请看源码，这是最主要的两个函数，能看出ThreadLocal与Thread的调用关系： 
public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
}

（有兴趣的朋友可以阅读Java的ThreadLocal源码）因此，我们可以知道，所谓的变量副本，即是对Object Reference（对象引用）的拷贝。

3.理解Thread和 ThreadLocal对变量的引用关系
    实际上Thread和ThreadLocal对变量引用关系就像是坐标系中的X轴和Y轴，是从两个维度上来组织对变量的引用的。
  • 首先说Thread。
    •     我们知道一个ThreadOne的执行会贯穿多个方法MethodA、MethodB、MethodC这些方法可能分布于不同的类实例。假设，这些方法分别使用了ThreadLocalA、ThreadLocalB、ThreadLocalC来保存线程本地变量，那么这些变量都存于ThreadOne的Map中，并使用各自的ThreadLocal实例作为key。 因此，可以认为，借助ThreanLocal的set方法，在X轴上，Thread横向关联同一线程上下文中来自多个Method的变量引用副本。



  • 接着说ThreadLocal。
    •     一个MethodA中的X变量将被多个线程ThreadOne、ThreadTwo、ThreadThree所访问。假设MethodA使用ThreadLocal存储X，通过set方法，以ThreadLocal作为key值，将不同线程来访时的不同的变量值引用保存于ThreadOne、ThreadTwo、ThreadThree的各自线程上下文中，确保每个线程有自己的一个变量值。因此，可以认为，ThreadLocal是以Method为Y轴，纵向关联了处于同一方法中的不同线程上的变量。



希望能对大家有所帮助，这样可以少走很多弯路哦。








18 楼 VerRan 2008-04-15  
好贴，支持下。
17 楼 linliangyi2007 2008-04-11  
xieke 写道
linliangyi2007 写道
rehte 写道
linliangyi2007 写道


楼上的，对纵向的理解是不对的。
变量x对于线程而言是安全的，而非不安全的。如果X是java的原生类型，则在每个线程中存在的是X的值副本；如果X是对象类型，那么每个线程中的对象引用也是不同的，因为对方法中的X的值改变，只影响当前X的引用（或者说指针的指向），不会影响其他线程的副本值，这也是所谓副本的含义。你可以做个实验。


当x是对象类型时，X必须是逃逸型引用，而不能是非逃逸型引用，即X是通过在本地方法中产生的，这就是所谓local的含义。如果X是非逃逸型的，则仍然有同步问题。
比如： 
class A{
    private Object v;
    public A(){
        v=new Object();
    }
    public ThreadLocal method1(){
        ThreadLocal local=new ThreadLocal();
        local.set(v); //对象v是非逃逸型引用，这儿的local所引用的对像是非同步安全的
        return local;
    }
    public ThreadLocal method2(){
        ThreadLocal local = new ThreadLocal();
        local.set(new Object()); //这儿的值是逃逸类型的，因此local是同步安全的
        return local;
    }
    public void methodUseLocal(){
        ThreadLocal local1=method1();
        Object tempv1=local1.get(); //这儿的tempv1其实就是this.v，因此是非线程安全的
        //...
        ThreadLocal local2=method2();
        Object tempv2=local2.get(); //这儿的tempv2是线程安全的，是和当前线程绑定的变量
        //...
    }
}



楼上提醒的是。实际上，我们对于一个方法是用ThreadLocal来对本地变量进行副本的时候，大多指的是方法内部变量（请看我的示意图，X是方法内部的local varible）。要对类变量进行共享的话，不是ThreadLocal设计的目的。
但确实存在这样的问题，值得大家注意。

方法内部变量 还用担心线程安全问题吗？
当然是类变量才需要担心了。

不太明白那个逃逸型非逃逸型是什么意思，
例子里面那个逃逸类型，及方法内部变量，没有线程安全问题，
非逃逸类型，用了ThreadLocal，自然也就安全了。


说的自己都晕了，一句话，ThreadLocal不是专门为线程安全而设计的，更多是为了变量的共享。
16 楼 xieke 2008-04-11  
linliangyi2007 写道
rehte 写道
linliangyi2007 写道


楼上的，对纵向的理解是不对的。
变量x对于线程而言是安全的，而非不安全的。如果X是java的原生类型，则在每个线程中存在的是X的值副本；如果X是对象类型，那么每个线程中的对象引用也是不同的，因为对方法中的X的值改变，只影响当前X的引用（或者说指针的指向），不会影响其他线程的副本值，这也是所谓副本的含义。你可以做个实验。


当x是对象类型时，X必须是逃逸型引用，而不能是非逃逸型引用，即X是通过在本地方法中产生的，这就是所谓local的含义。如果X是非逃逸型的，则仍然有同步问题。
比如： 
class A{
    private Object v;
    public A(){
        v=new Object();
    }
    public ThreadLocal method1(){
        ThreadLocal local=new ThreadLocal();
        local.set(v); //对象v是非逃逸型引用，这儿的local所引用的对像是非同步安全的
        return local;
    }
    public ThreadLocal method2(){
        ThreadLocal local = new ThreadLocal();
        local.set(new Object()); //这儿的值是逃逸类型的，因此local是同步安全的
        return local;
    }
    public void methodUseLocal(){
        ThreadLocal local1=method1();
        Object tempv1=local1.get(); //这儿的tempv1其实就是this.v，因此是非线程安全的
        //...
        ThreadLocal local2=method2();
        Object tempv2=local2.get(); //这儿的tempv2是线程安全的，是和当前线程绑定的变量
        //...
    }
}



楼上提醒的是。实际上，我们对于一个方法是用ThreadLocal来对本地变量进行副本的时候，大多指的是方法内部变量（请看我的示意图，X是方法内部的local varible）。要对类变量进行共享的话，不是ThreadLocal设计的目的。
但确实存在这样的问题，值得大家注意。

方法内部变量 还用担心线程安全问题吗？
当然是类变量才需要担心了。

不太明白那个逃逸型非逃逸型是什么意思，
例子里面那个逃逸类型，及方法内部变量，没有线程安全问题，
非逃逸类型，用了ThreadLocal，自然也就安全了。
15 楼 hustlong 2008-04-10  
嗯，学习了
14 楼 linliangyi2007 2008-04-08  
rehte 写道
linliangyi2007 写道


楼上的，对纵向的理解是不对的。
变量x对于线程而言是安全的，而非不安全的。如果X是java的原生类型，则在每个线程中存在的是X的值副本；如果X是对象类型，那么每个线程中的对象引用也是不同的，因为对方法中的X的值改变，只影响当前X的引用（或者说指针的指向），不会影响其他线程的副本值，这也是所谓副本的含义。你可以做个实验。


当x是对象类型时，X必须是逃逸型引用，而不能是非逃逸型引用，即X是通过在本地方法中产生的，这就是所谓local的含义。如果X是非逃逸型的，则仍然有同步问题。
比如： 
class A{
    private Object v;
    public A(){
        v=new Object();
    }
    public ThreadLocal method1(){
        ThreadLocal local=new ThreadLocal();
        local.set(v); //对象v是非逃逸型引用，这儿的local所引用的对像是非同步安全的
        return local;
    }
    public ThreadLocal method2(){
        ThreadLocal local = new ThreadLocal();
        local.set(new Object()); //这儿的值是逃逸类型的，因此local是同步安全的
        return local;
    }
    public void methodUseLocal(){
        ThreadLocal local1=method1();
        Object tempv1=local1.get(); //这儿的tempv1其实就是this.v，因此是非线程安全的
        //...
        ThreadLocal local2=method2();
        Object tempv2=local2.get(); //这儿的tempv2是线程安全的，是和当前线程绑定的变量
        //...
    }
}



楼上提醒的是。实际上，我们对于一个方法是用ThreadLocal来对本地变量进行副本的时候，大多指的是方法内部变量（请看我的示意图，X是方法内部的local varible）。要对类变量进行共享的话，不是ThreadLocal设计的目的。
但确实存在这样的问题，值得大家注意。
13 楼 rehte 2008-04-08  
linliangyi2007 写道


楼上的，对纵向的理解是不对的。
变量x对于线程而言是安全的，而非不安全的。如果X是java的原生类型，则在每个线程中存在的是X的值副本；如果X是对象类型，那么每个线程中的对象引用也是不同的，因为对方法中的X的值改变，只影响当前X的引用（或者说指针的指向），不会影响其他线程的副本值，这也是所谓副本的含义。你可以做个实验。


当x是对象类型时，X必须是逃逸型引用，而不能是非逃逸型引用，即X是通过在本地方法中产生的，这就是所谓local的含义。如果X是非逃逸型的，则仍然有同步问题。
比如： 
class A{
    private Object v;
    public A(){
        v=new Object();
    }
    public ThreadLocal method1(){
        ThreadLocal local=new ThreadLocal();
        local.set(v); //对象v是非逃逸型引用，这儿的local所引用的对像是非同步安全的
        return local;
    }
    public ThreadLocal method2(){
        ThreadLocal local = new ThreadLocal();
        local.set(new Object()); //这儿的值是逃逸类型的，因此local是同步安全的
        return local;
    }
    public void methodUseLocal(){
        ThreadLocal local1=method1();
        Object tempv1=local1.get(); //这儿的tempv1其实就是this.v，因此是非线程安全的
        //...
        ThreadLocal local2=method2();
        Object tempv2=local2.get(); //这儿的tempv2是线程安全的，是和当前线程绑定的变量
        //...
    }
}
12 楼 lendo.du 2008-04-08  
写的很不错。我很欣赏你。
11 楼 linliangyi2007 2008-04-08  
spiritfrog 写道
感觉这样解释反而变得有些麻烦了，直接看下源码倒简单些。
横向的实际上是，同一个线程a中，三个threadlocal对象保存x，y，z，实际上在a线程的map中，以threadlocal对象为key保存x，y，z
纵向的，说的是不同线程的情况，分别用threadlocal保存对象x，结果每个线程的map都保存了x。实际上这个x也是不安全的，因为三个线程都能访问它，如果能修改的话。


楼上的，对纵向的理解是不对的。
变量x对于线程而言是安全的，而非不安全的。如果X是java的原生类型，则在每个线程中存在的是X的值副本；如果X是对象类型，那么每个线程中的对象引用也是不同的，因为对方法中的X的值改变，只影响当前X的引用（或者说指针的指向），不会影响其他线程的副本值，这也是所谓副本的含义。你可以做个实验。

10 楼 spiritfrog 2008-04-07  
感觉这样解释反而变得有些麻烦了，直接看下源码倒简单些。
横向的实际上是，同一个线程a中，三个threadlocal对象保存x，y，z，实际上在a线程的map中，以threadlocal对象为key保存x，y，z
纵向的，说的是不同线程的情况，分别用threadlocal保存对象x，结果每个线程的map都保存了x。实际上这个x也是不安全的，因为三个线程都能访问它，如果能修改的话。
9 楼 galaxystar 2008-04-07  
写的不错。
另外，创建一个代理类，来负责某一种业务的线程变量存储，应该不错。
这样，ThreadLocal不用重复创建。
8 楼 linliangyi2007 2008-04-07  
bluemeteor 写道
linliangyi2007 写道
   
  • 首先说Thread。
    •     我们知道一个ThreadOne的执行会贯穿多个方法MethodA、MethodB、MethodC这些方法可能分布于不同的类实例。假设，这些方法都使用了ThreadLocal来保存线程本地变量，那么这些变量都存于ThreadOne的Map中，并使用ThreadLocal作为key。 因此，可以认为，借助ThreanLocal的set方法，在X轴上，Thread横向关联同一线程上下文中来自多个Method的变量引用副本。



    建议说明一下MethodA~C分别对应ThreadLocal变量A~C，否则可能容易导致误解


    感谢兄台提醒，已经对原文作了修改！
    7 楼 bluemeteor 2008-04-07  
    linliangyi2007 写道
       
  • 首先说Thread。
    •     我们知道一个ThreadOne的执行会贯穿多个方法MethodA、MethodB、MethodC这些方法可能分布于不同的类实例。假设，这些方法都使用了ThreadLocal来保存线程本地变量，那么这些变量都存于ThreadOne的Map中，并使用ThreadLocal作为key。 因此，可以认为，借助ThreanLocal的set方法，在X轴上，Thread横向关联同一线程上下文中来自多个Method的变量引用副本。



    建议说明一下MethodA~C分别对应ThreadLocal变量A~C，否则可能容易导致误解
    6 楼 luanma 2008-04-07  
    线程本地变量
    5 楼 andy54321 2008-04-06  
    的确，图文并茂，

    好文章，长见识了，

    以后不管学习还是给人讲解都得向LZ学习
    4 楼 snailness 2008-04-05  
    好文!我们公司的框架对参数的保存就是通过threadlocal,一直懵懵懂懂,看了楼主的文章,如醍醐灌顶啊!~~~~~~~~~~~~~~
    3 楼 fuliang 2008-04-05  
    ThreadLocal要实现的就是线程的Local variable,源代码看起来绕了一个弯：
    Thread里有ThreadLocalMap threadLocals,这样getMap(t),返回这个Map,
    而这个Map的key和value分别是ThreadLocal和Local variable[要存入的副本]。
    其实理解上可以简化为：ThreadLocal就是把副本绑定到一个线程上的Map。(只是实现上费了点周折而已)
    2 楼 darkjune 2008-04-05  
    好文,看了图就很清楚了
    发表评论

    您还没有登录,请您登录后再发表评论

    相关推荐

    Magicbox
    Global site tag (gtag.js) - Google Analytics