简明扼要，再谈ThreadLocal和synchronized

linliangyi2007

浏览: 1013023 次
性别:
来自: 福州

最近访客更多访客>>

anyitzy

pos3721

ymgjava

winco304

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

程序人生

thread JVM 框架

    昨天上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。

接着说ThreadLocal。

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

分享到：

jQuery1.2 API 帮助文档共享 | 很“水产”的史前一万年

2008-04-03 01:43
浏览 9307
评论(21)
论坛回复 / 浏览 (11 / 23029)
查看更多

21 楼 ariestiger 2012-12-25

ThreadLocal只是一个key，不同的Thread可以通过这个key拿到不同的值（其实这值都存放在该Thread中），看看ThreadLocal中get, set方法就全清楚了。

20 楼 jeffmacn 2011-08-18

每个线程一个拷贝，那这个拷贝工作是何时在哪做的？源代码在哪？

19 楼 jzhua2006 2009-01-13

linliangyi2007 写道

ThreadLocal是一个线程隔离(或者说是线程安全)的变量存储的管理实体（注意：不是存储用的），它以Java类方式表现；
synchronized是Java的一个保留字，只是一个代码标识符，它依靠JVM的锁机制来实现临界区的函数、变量在CPU运行访问中的原子性。

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;
}

首先说Thread。

接着说ThreadLocal。

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

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 写道

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是线程安全的，是和当前线程绑定的变量
        //...
    }
}

15 楼 hustlong 2008-04-10

嗯，学习了

14 楼 linliangyi2007 2008-04-08

rehte 写道

linliangyi2007 写道

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是线程安全的，是和当前线程绑定的变量
        //...
    }
}

13 楼 rehte 2008-04-08

linliangyi2007 写道

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也是不安全的，因为三个线程都能访问它，如果能修改的话。

10 楼 spiritfrog 2008-04-07

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。

建议说明一下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

好文,看了图就很清楚了

发表评论

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

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论