ThreadLocal与synchronized

klyuan

浏览: 184598 次
性别:
来自: 深圳

最近访客更多访客>>

coldg

whowhopipi

ispring

novoland

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

java

多线程 thread 申诉 Spring Hibernate

ThreadLocal与synchronized
Java良好的支持多线程。使用java,我们可以很轻松的编程一个多线程程序。但是使用多线程可能会引起并发访问的问题。synchronized和ThreadLocal都是用来解决多线程并发访问的问题。大家可能对synchronized较为熟悉，而对ThreadLocal就要陌生得多了。
并发问题。当一个对象被两个线程同时访问时，可能有一个线程会得到不可预期的结果。

一个简单的java类Studnet

public class Student {
  private int age=0;
  
  public int getAge() {
	  return this.age;
	  
  }
  
  public void setAge(int age) {
	  this.age = age;
  }
}

一个多线程类ThreadDemo.
这个类有一个Student的私有变量,在run方法中，它随机产生一个整数。然后设置到student变量中,从student中读取设置后的值。然后睡眠5秒钟，最后再次读student的age值。

public class ThreadDemo implements Runnable{
  Student student = new Student();
  public static void main(String[] agrs) {
	 ThreadDemo td = new ThreadDemo();
	 Thread t1 = new Thread(td,"a");
	 Thread t2 = new Thread(td,"b");
    t1.start();
    t2.start();

  }
/* (non-Javadoc)
 * @see java.lang.Runnable#run()
 */
 public void run() {
	 accessStudent();
 }
 
 public void accessStudent() {
	    String currentThreadName = Thread.currentThread().getName();
	    System.out.println(currentThreadName+" is running!");
	   // System.out.println("first  read age is:"+this.student.getAge());
	    Random random = new Random();
	    int age = random.nextInt(100);
	    System.out.println("thread "+currentThreadName +" set age to:"+age);
	   
	    this.student.setAge(age);
	    System.out.println("thread "+currentThreadName+" first  read age is:"+this.student.getAge());
	    try {
	    Thread.sleep(5000);
	    }
	    catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());
	     
 }
  
}

运行这个程序,屏幕输出如下:
a is running!
b is running!
thread b set age to:33
thread b first read age is:33
thread a set age to:81
thread a first read age is:81
thread b second read age is:81
thread a second read age is:81

需要注意的是，线程a在同一个方法中，第一次读取student的age值与第二次读取值不一致。这就是出现了并发问题。

synchronized
上面的例子，我们模似了一个并发问题。Java提供了同步机制来解决并发问题。synchonzied关键字可以用来同步变量，方法，甚至同步一个代码块。
使用了同步后，一个线程正在访问同步对象时，另外一个线程必须等待。
Synchronized同步方法
现在我们可以对accessStudent方法实施同步。
public synchronized void accessStudent()
再次运行程序，屏幕输出如下：
a is running!
thread a set age to:49
thread a first read age is:49
thread a second read age is:49
b is running!
thread b set age to:17
thread b first read age is:17
thread b second read age is:17

加上了同步后，线程b必须等待线程a执行完毕后，线程b才开始执行。

对方法进行同步的代价是非常昂贵的。特别是当被同步的方法执行一个冗长的操作。这个方法执行会花费很长的时间,对这样的方法进行同步可能会使系统性能成数量级的下降。

Synchronized同步块
在accessStudent方法中，我们真实需要保护的是student变量，所以我们可以进行一个更细粒度的加锁。我们仅仅对student相关的代码块进行同步。

	    synchronized(this) {
	    Random random = new Random();
	    int age = random.nextInt(100);
	    System.out.println("thread "+currentThreadName +" set age to:"+age);
	   
	    this.student.setAge(age);
	   
	    System.out.println("thread "+currentThreadName+" first  read age is:"+this.student.getAge());
	    try {
	    Thread.sleep(5000);
	    }
	    catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    }

运行方法后，屏幕输出：
a is running!
thread a set age to:18
thread a first read age is:18
b is running!
thread a second read age is:18
thread b set age to:62
thread b first read age is:62
thread b second read age is:62

需要特别注意这个输出结果。
这个执行过程比上面的方法同步要快得多了。
只有对student进行访问的代码是同步的，而其它与部份代码却是异步的了。而student的值并没有被错误的修改。如果是在一个真实的系统中，accessStudent方法的操作又比较耗时的情况下。使用同步的速度几乎与没有同步一样快。

使用同步锁
稍微把上面的例子改一下，在ThreadDemo中有一个私有变量count，。
private int count=0;
在accessStudent()中, 线程每访问一次，count都自加一次, 用来记数线程访问的次数。

	    try {
	    this.count++;
	    Thread.sleep(5000);
	    }catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }

为了模拟线程，所以让它每次自加后都睡眠5秒。
accessStuden()方法的完整代码如下：

   	    String currentThreadName = Thread.currentThread().getName();
	    System.out.println(currentThreadName+" is running!");
			    try {
	    this.count++;
	    Thread.sleep(5000);
	    }catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
		    System.out.println("thread "+currentThreadName+" read count:"+this.count);
	    
	   
	    synchronized(this) {
	    Random random = new Random();
	    int age = random.nextInt(100);
	    System.out.println("thread "+currentThreadName +" set age to:"+age);
	   
	    this.student.setAge(age);
	   
	    System.out.println("thread "+currentThreadName+" first  read age is:"+this.student.getAge());
	    try {
	    Thread.sleep(5000);
	    }
	    catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    }
	    System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());

运行程序后，屏幕输出:
a is running!
b is running!
thread a read count:2
thread a set age to:49
thread a first read age is:49
thread b read count:2
thread a second read age is:49
thread b set age to:7
thread b first read age is:7
thread b second read age is:7

我们仍然对student对象以synchronized(this)操作进行同步。
我们需要在两个线程中共享count失败。

所以仍然需要对count的访问进行同步操作。

		 synchronized(this) {
	    try {
	    this.count++;
	    Thread.sleep(5000);
	    }catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    }
	    System.out.println("thread "+currentThreadName+" read count:"+this.count);
	    
	   
	    synchronized(this) {
	    Random random = new Random();
	    int age = random.nextInt(100);
	    System.out.println("thread "+currentThreadName +" set age to:"+age);
	   
	    this.student.setAge(age);
	   
	    System.out.println("thread "+currentThreadName+" first  read age is:"+this.student.getAge());
	    try {
	    Thread.sleep(5000);
	    }
	    catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    }
	    System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());
	    long endTime = System.currentTimeMillis();
	    long spendTime = endTime - startTime;
	    System.out.println("花费时间："+spendTime +"毫秒");

程序运行后，屏幕输出
a is running!
b is running!
thread a read count:1
thread a set age to:97
thread a first read age is:97
thread a second read age is:97
花费时间：10015毫秒
thread b read count:2
thread b set age to:47
thread b first read age is:47
thread b second read age is:47
花费时间：20124毫秒

我们在同一个方法中，多次使用synchronized(this)进行加锁。有可能会导致太多额外的等待。
应该使用不同的对象锁进行同步。

设置两个锁对象，分别用于student和count的访问加锁。

 private Object studentLock = new Object();
private Object countLock = new Object();

accessStudent()方法如下：
	 long startTime = System.currentTimeMillis();
	    String currentThreadName = Thread.currentThread().getName();
	    System.out.println(currentThreadName+" is running!");
	   // System.out.println("first  read age is:"+this.student.getAge());

		 synchronized(countLock) {
	    try {
	    this.count++;
	    Thread.sleep(5000);
	    }catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    }
	    System.out.println("thread "+currentThreadName+" read count:"+this.count);
	    
	   
	    synchronized(studentLock) {
	    Random random = new Random();
	    int age = random.nextInt(100);
	    System.out.println("thread "+currentThreadName +" set age to:"+age);
	   
	    this.student.setAge(age);
	   
	    System.out.println("thread "+currentThreadName+" first  read age is:"+this.student.getAge());
	    try {
	    Thread.sleep(5000);
	    }
	    catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    }
	    System.out.println("thread "+currentThreadName +" second read age is:"+this.student.getAge());
	    long endTime = System.currentTimeMillis();
	    long spendTime = endTime - startTime;
	    System.out.println("花费时间："+spendTime +"毫秒");

这样对count和student加上了两把不同的锁。

运行程序后，屏幕输出：
a is running!
b is running!
thread a read count:1
thread a set age to:48
thread a first read age is:48
thread a second read age is:48
花费时间：10016毫秒
thread b read count:2
thread b set age to:68
thread b first read age is:68
thread b second read age is:68
花费时间：20046毫秒
与两次使用synchronized(this)相比，使用不同的对象锁，在性能上可以得到更大的提升。

由此可见synchronized是实现java的同步机制。同步机制是为了实现同步多线程对相同资源的并发访问控制。保证多线程之间的通信。
可见，同步的主要目的是保证多线程间的数据共享。同步会带来巨大的性能开销，所以同步操作应该是细粒度的。如果同步使用得当，带来的性能开销是微不足道的。使用同步真正的风险是复杂性和可能破坏资源安全,而不是性能。

ThreadLocal
由上面可以知道，使用同步是非常复杂的。并且同步会带来性能的降低。Java提供了另外的一种方式，通过ThreadLocal可以很容易的编写多线程程序。从字面上理解，很容易会把ThreadLocal误解为一个线程的本地变量。其它ThreadLocal并不是代表当前线程，ThreadLocal其实是采用哈希表的方式来为每个线程都提供一个变量的副本。从而保证各个线程间数据安全。每个线程的数据不会被另外线程访问和破坏。

我们把第一个例子用ThreadLocal来实现,但是我们需要些许改变。
Student并不是一个私有变量了，而是需要封装在一个ThreadLocal对象中去。调用ThreadLocal的set方法，ThreadLocal会为每一个线程都保持一份Student变量的副本。所以对student的读取操作都是通过ThreadLocal来进行的。

	protected Student getStudent() {
		Student student = (Student)studentLocal.get();
		if(student == null) {
			student = new Student();
			studentLocal.set(student);
		}
		return student;
	}
	
	protected void setStudent(Student student) {
		studentLocal.set(student);
	}

accessStudent()方法需要做一些改变。通过调用getStudent()方法来获得当前线程的Student变量，如果当前线程不存在一个Student变量，getStudent方法会创建一个新的Student变量，并设置在当前线程中。
Student student = getStudent();
student.setAge(age);
accessStudent()方法中无需要任何同步代码。

完整的代码清单如下：
TreadLocalDemo.java

public class TreadLocalDemo implements Runnable {
   private final static  ThreadLocal studentLocal = new ThreadLocal();
   
   public static void main(String[] agrs) {
	   TreadLocalDemo td = new TreadLocalDemo();
		 Thread t1 = new Thread(td,"a");
		 Thread t2 = new Thread(td,"b");
		
	    t1.start();
	    t2.start();
	   
	   


	  }
   
	/* (non-Javadoc)
	 * @see java.lang.Runnable#run()
	 */
	public void run() {
		 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(5000);
	    }
	    catch(InterruptedException ex) {
	    	ex.printStackTrace();
	    }
	    System.out.println("thread "+currentThreadName +" second read age is:"+student.getAge());
	    
	}
	
	protected Student getStudent() {
		Student student = (Student)studentLocal.get();
		if(student == null) {
			student = new Student();
			studentLocal.set(student);
		}
		return student;
	}
	
	protected void setStudent(Student student) {
		studentLocal.set(student);
	}
}

运行程序后，屏幕输出：
b is running!
thread b set age to:0
thread b first read age is:0
a is running!
thread a set age to:17
thread a first read age is:17
thread b second read age is:0
thread a second read age is:17

可见，使用ThreadLocal后，我们不需要任何同步代码，却能够保证我们线程间数据的安全。
而且，ThreadLocal的使用也非常的简单。
我们仅仅需要使用它提供的两个方法
void set(Object obj) 设置当前线程的变量的副本的值。
Object get() 返回当前线程的变量副本

另外ThreadLocal还有一个protected的initialValue()方法。返回变量副本在当前线程的初始值。默认为null

ThreadLocal是怎么做到为每个线程都维护一个变量的副本的呢？
我们可以猜测到ThreadLocal的一个简单实现

public class ThreadLocal
{
　private Map values = Collections.synchronizedMap(new HashMap());
　public Object get()
　{
　　Thread curThread = Thread.currentThread(); 
　　Object o = values.get(curThread); 
　　if (o == null && !values.containsKey(curThread))
　　{
　　　o = initialValue();
　　　values.put(curThread, o); 
　　}
　　return o; 
　}

　public void set(Object newValue)
　{
　　values.put(Thread.currentThread(), newValue);
　}

　public Object initialValue()
　{
　　return null; 
　}
}

由此可见，ThreadLocal通过一个Map来为每个线程都持有一个变量副本。这个map以当前线程为key。与synchronized相比，ThreadLocal是以空间换时间的策略来实现多线程程序。

Synchronized还是ThreadLocal?
ThreadLocal以空间换取时间，提供了一种非常简便的多线程实现方式。因为多个线程并发访问无需进行等待，所以使用ThreadLocal会获得更大的性能。虽然使用ThreadLocal会带来更多的内存开销，但这点开销是微不足道的。因为保存在ThreadLocal中的对象，通常都是比较小的对象。另外使用ThreadLocal不能使用原子类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。
ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。
Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。
当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制，比ThreadLocal更加复杂。

分享到：

Spring JavaConfig开发指南(上) | 倒底该怎么写DAO的单元测试？

2007-05-22 17:49
浏览 27424
评论(91)
论坛回复 / 浏览 (83 / 107661)
分类:企业架构
查看更多

51 楼 lujh99 2007-05-26

fujohnwang 写道

呵呵，ThreadLocal那叫Thread specified，LZ估计只是想说明特定环境下特定问题解决方式的选择，没必要争论人家的文字怎么样吧，hoho，要不我写一篇？！（没空）

不是文字上的问题，是概念上的问题，楼主对ThreadLocal的理解是完全错误的，什么副本啊，正确得理解好多人都说了。
ThreadLocal不能解决多线程的共享资源访问问题，最好由楼主自己出来澄清一下，免得误导别人。

50 楼 fujohnwang 2007-05-26

49 楼 lujh99 2007-05-25

是啊，楼主和好多人一样对ThreadLocal的理解有较大的偏差，可以看看这一篇文章：http://www.iteye.com/topic/71554，里面介绍的很清楚，相信对大家有帮助。

48 楼 daquan198163 2007-05-25

ahuaxuan 写道

我们看看jdk中的ThreadLocal就知道了：

public Object get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) 
            return map.get(this);

        // Maps are constructed lazily.  if the map for this thread
        // doesn't exist, create it, with this ThreadLocal and its
        // initial value as its only entry.
        Object value = initialValue();
        createMap(t, value);
        return value;
    }

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

    void createMap(Thread t, Object firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

哦,是我搞错了.又仔细看了一下这段代码

47 楼 Godlikeme 2007-05-25

to daquan: ahuaxuan说的没错。

46 楼 calmness 2007-05-25

引用

Synchronized还是ThreadLocal?
ThreadLocal以空间换取时间，提供了一种非常简便的多线程实现方式。因为多个线程并发访问无需进行等待，所以使用ThreadLocal会获得更大的性能。虽然使用ThreadLocal会带来更多的内存开销，但这点开销是微不足道的。因为保存在ThreadLocal中的对象，通常都是比较小的对象。另外使用ThreadLocal不能使用原子类型，只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。

其他先不说，我想通过这段话就可以看出你把Synchronized和ThreadLocal放在可比可替换的情况下了吧，至少这里就已经做出了误导。

45 楼 daquan198163 2007-05-25

ahuaxuan 写道

但是事实上不是这样的。
ThreadLocal应该是一个工具类，把数据通过ThreadLocal放到线程中去而已，每个线程都有自己的一个ThreadLocalMap（这个Map类是ThreadLocal的一个内部类）来存放这些变量，而楼主的代码是把这个变量存放在ThreadLocal中,在ThreadLocal中又对这个map进行同步。这个明显是不对的
ps:楼主的文章误导人的字句确实不少（还有代码），如果改过来可投良好

应该是每个变量有一个ThreadLocalMap,然后每个ThreadLocalMap被所有线程共享吧?

我觉得楼主把这两个东西拿到一起来讨论是合理地,因为现实情况是:开发人员在很多没有必要用实例变量的场合却使用了一个实例变量,由此导致为了线程安全而使用synchronize,增加了复杂度,还有性能\死锁问题
而这种情况是可以用ThreadLocal来解决的
当然,需要在线程之间共享数据的时候,还是要用实例变量地

44 楼 cherami 2007-05-25

ThreadLocal和synchronized除了都和多线程有关外，是没有太多的可比性，不应该放在一起说，这样确实会误导新手。

XMLDB的观点正解：
ThreadLocal解决的是同一个线程内的资源共享问题，而synchronized 解决的是多个线程间的资源共享问题，两个问题没有可比性。

43 楼 ahuaxuan 2007-05-25

klyuan 写道

BirdGu 写道

spiritfrog 写道

XMLDB 写道

LZ把概念搞错了，ThreadLocal就是ThreadLocal，和同步完全没有关系。
ThreadLocal解决的是同一个线程内的资源共享问题，而synchronized 解决的是多个线程间的资源共享问题，两个问题没有可比性。

lz的文章并没有去讨论ThreadLocal就是ThreadLocal有什么关系，只是在说如何保证多线程环境下对共享资源访问的数据安全。文章看完了，简单明了，很到位，是篇好文章。

麻烦你解释一下，ThreadLocal是怎么“保证多线程环境下对共享资源访问的数据安全”的？ThreadLocal使各个线程使用各自不同的数据，这种情况下哪来的“共享资源”？

就是告诉你多线程的时候什么时候用ThreadLocal,什么时候用而synchronized

事实上，ThreadLocal就是为了不要数据共享，而是每个线程都有自己的数据，ThreadLocal和同步根本是不搭界的，而在楼主的文章里好像更容易把糊涂的人搞糊涂
再举个例子
楼主贴的ThreadLocal的猜想：

public class ThreadLocal   
{   
　private Map values = Collections.synchronizedMap(new HashMap());   
　public Object get()   
　{   
　　Thread curThread = Thread.currentThread();    
　　Object o = values.get(curThread);    
　　if (o == null && !values.containsKey(curThread))   
　　{   
　　　o = initialValue();   
　　　values.put(curThread, o);    
　　}   
　　return o;    
　}   
  
　public void set(Object newValue)   
　{   
　　values.put(Thread.currentThread(), newValue);   
　}   
  
　public Object initialValue()   
　{   
　　return null;    
　}   
}

public Object get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) 
            return map.get(this);

        // Maps are constructed lazily.  if the map for this thread
        // doesn't exist, create it, with this ThreadLocal and its
        // initial value as its only entry.
        Object value = initialValue();
        createMap(t, value);
        return value;
    }

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

    void createMap(Thread t, Object firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

ps:楼主的文章误导人的字句确实不少（还有代码），如果改过来可投良好

42 楼 klyuan 2007-05-25

BirdGu 写道

spiritfrog 写道

XMLDB 写道

就是告诉你多线程的时候什么时候用ThreadLocal,什么时候用而synchronized

41 楼 klyuan 2007-05-25

jindw 写道

weiqingfei 写道

jindw 写道

weiqingfei 写道

其实两个本来就没有关系，我想楼主只是想说如何在多线程中活用ThreadLocal。

ThreadLocal的实现本来就比较简单，只是用线程来作为key来寻找本线程中所使用的一个实例，它解决的最主要的问题应该就是减少参数的传递。

说句没有意义的话，事实上。ThreadLocal实现中，作为key的不是线程，而是ThreadLocal本身。

从整体上来看好吧。
不要看到ThreadLocalMap的key是ThreadLocal，就认为寻找线程本地变量实例的key就是ThreadLocal了。

要知道每个线程都会持有一个ThreadLocalMap的实例，我说的key就是这个意思。
key只是找到目标的钥匙，不是只有map才有key。

你的话也有道理，但是，说到这个细节，我还是要说一下，ThreadLocal要比我们简单的想象复杂的多，不单是一个变量存储，它的数据方Thread里面，很明显，在线程销毁时的清理任务。

可以说ThreadLocal是个系统级的API，比我们想象的要复杂一点。

文中那个ThreadLocal的实现代码仅是一些猜想和stub!
为了更好的说明ThreadLocal

40 楼 klyuan 2007-05-25

calmness 写道

LZ在ThreadLocal的使用上有误导，ThreadLocal并非是用于解决同步问题的，存在同步问题的问题它也解决不了，比如说一个统计类的系统，你能用ThreadLocal做到吗？难道为每个线程都copy一个计数器吗？那有什么用？ThreadLocal与synchronized 在使用上是没有可比性的，更没有谁替代谁的说法，帖子被评良好会导致不了解的人误解的。

你可能没有看完全文吧！！！
从来没有说过要用ThreadLocal代替synchronized

39 楼 klyuan 2007-05-25

Godlikeme 写道

daquan，你把问题改变了，

本身问题关键字，多线程共享资源访问数据安全。

别再这里浪费生命了，有空好好看看ThreadLocal 的javadoc,说得很清楚。
不要因为都和多线程有关系，把threadLocal和synchronized往一块扯。

不是把它们一起扯，是要分清楚！！！

38 楼林秋枫 2007-05-25

jdk1.5中有比synchronized 更好的同步机制.

37 楼 calmness 2007-05-25

36 楼 Godlikeme 2007-05-25

nod，
ThreadLocal类似一个 Thread Context，减少调用、传参复杂度，增加环境依赖。

35 楼 BirdGu 2007-05-25

引用

在同一个线程内，完全不相关的两个段代码、函数之间如何共享一个变量呢？通过ThreadLocal可以做到。而且这两段代码之间不用显式的传递参数，降低了耦合

使用同一个变量名，只能叫“共享变量名”，不能叫“共享资源”。共享资源一定是指共享同一个对象（实例）。

ThreadLocal可以看成是线程范围内的全局变量。用ThreadLocal代替参数传递是降低了耦合？那全局变量也能降低耦合了？

34 楼 Godlikeme 2007-05-25

33 楼 daquan198163 2007-05-25

BirdGu 写道

spiritfrog 写道

XMLDB 写道

在同一个线程内，完全不相关的两个段代码、函数之间如何共享一个变量呢？通过ThreadLocal可以做到
而且这两段代码之间不用显式的传递参数，降低了耦合

32 楼 Godlikeme 2007-05-25

to ls：
变量的副本是自己特定的意义。
各线程取得线程相关不同实例是完全另外一回事。

« 上一页 1 2 3 4 5 下一页 »

发表评论

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

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论