一.ThreadLocal的用法
ThreadLocal的实现:
- package com.sodao.lucene;
- import java.util.Random;
- public class ThreadLocalTest implements Runnable{
- ThreadLocal<Studen> studenThreadLocal = new ThreadLocal<Studen>();
- @Override
- public void run() {
- String currentThreadName = Thread.currentThread().getName();
- System.out.println(currentThreadName + " is running...");
- Random random = new Random();
- int age = random.nextInt(100);
- System.out.println(currentThreadName + " is set age: " + age);
- Studen studen = getStudent(); //通过这个方法,为每个线程都独立的new一个student对象,每个线程的的student对象都可以设置不同的值
- studen.setAge(age);
- System.out.println(currentThreadName + " is first get age: " + studen.getAge());
- try {
- Thread.sleep(500);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println( currentThreadName + " is second get age: " + studen.getAge());
- }
- private Studen getStudent() {
- Studen studen = studenThreadLocal.get();
- if (null == studen) {
- studen = new Studen();
- studenThreadLocal.set(studen);
- }
- return studen;
- }
- public static void main(String[] args) {
- ThreadLocalTest t = new ThreadLocalTest();
- Thread t1 = new Thread(t,"Thread A");
- Thread t2 = new Thread(t,"Thread B");
- t1.start();
- t2.start();
- }
- }
- class Studen{
- int age;
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- }
Synchronized的实现:
- package com.sodao.lucene;
- import java.util.Random;
- public class MultiThreadTest implements Runnable{
- Studen studen = new Studen();
- @Override
- public void run() {
- String currentThreadName = Thread.currentThread().getName();
- System.out.println(currentThreadName + " is running ....");
- //同步
- synchronized (studen) {
- Random random = new Random();
- int age = random.nextInt(100);
- studen.setAge(age);
- System.out.println(currentThreadName + " is set age: " + age);
- System.out.println(currentThreadName + "is first get age: " + studen.getAge() );
- try {
- Thread.sleep(500);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(currentThreadName + " is second get age: " + studen.getAge() );
- }
- }
- public static void main(String[] args) {
- MultiThreadTest m = new MultiThreadTest();
- Thread t1 = new Thread(m,"Thread A");
- Thread t2 = new Thread(m,"Thread B");
- t1.start();
- t2.start();
- }
- }
- class Student {
- int age;
- public int getAge() {
- return age;
- }
- public void setAge(int age) {
- this.age = age;
- }
- }
以上2中方法都实现的功能相同,但方法不一样
ThreadLocal使用场合主要解决多线程中数据数据因并发产生不一致问题。ThreadLocal为每个线程的中并发访问的数据提供一个副本,通过访问副本来运行业务,这样的结果是耗费了内存,单大大减少了线程同步所带来性能消耗,也减少了线程并发控制的复杂度。
ThreadLocal不能使用原子类型,只能使用Object类型。ThreadLocal的使用比synchronized要简单得多。
ThreadLocal和Synchonized都用于解决多线程并发访问。但是ThreadLocal与synchronized有本质的区别。synchronized是利用锁的机制,使变量或代码块在某一时刻只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本,使得每个线程在某一时间访问到的并不是同一个对象,这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反,它用于在多个线程间通信时能够获得数据共享。
Synchronized用于线程间的数据共享,而ThreadLocal则用于线程间的数据隔离。
当然ThreadLocal并不能替代synchronized,它们处理不同的问题域。Synchronized用于实现同步机制,比ThreadLocal更加复杂。
ThreadLocal使用的一般步骤:
1、在多线程的类(如ThreadDemo类)中,创建一个ThreadLocal对象threadXxx,用来保存线程间需要隔离处理的对象xxx。
2、在ThreadDemo类中,创建一个获取要隔离访问的数据的方法getXxx(),在方法中判断,若ThreadLocal对象为null时候,应该new()一个隔离访问类型的对象,并强制转换为要应用的类型。
3、在ThreadDemo类的run()方法中,通过getXxx()方法获取要操作的数据,这样可以保证每个线程对应一个数据对象,在任何时刻都操作的是这个对象。
Come From:http://gcgmh.javaeye.com/blog/455940
二.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更加复杂。
Come From: http://www.javaeye.com/topic/81936
http://www.javaeye.com/topic/103804
http://blog.csdn.net/yangairong1984/archive/2008/04/15/2294572.aspx