ThreadLocal与Synchronized的用法

来源：http://blog.csdn.net/wl_ldy/article/details/5948779

一.ThreadLocal的用法

ThreadLocal的实现：

public class ThreadLocalTest implements Runnable{                  ThreadLocal<Student> studenThreadLocal = new ThreadLocal<Student>();             @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);                //通过这个方法，为每个线程都独立的new一个student对象，每个线程的的student对象都可以设置不同的值        Student student = getStudent();         student.setAge(age);             System.out.println(currentThreadName + " is first get age: " + student.getAge());                 try {                 Thread.sleep(500);             } catch (InterruptedException e) {                 e.printStackTrace();             }             System.out.println( currentThreadName + " is second get age: " + student.getAge());                      }                  private Student getStudent() {             Student student = studenThreadLocal.get();             if (null == student) {                 student = new Student();                 studenThreadLocal.set(student);             }             return student;         }             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 Student{         int age;             public int getAge() {             return age;         }             public void setAge(int age) {             this.age = age;         }              }

Synchronized的实现：

public class MultiThreadTest  implements Runnable{                  Student student = new Student();                  @Override        public void run() {             String currentThreadName = Thread.currentThread().getName();             System.out.println(currentThreadName + " is running ....");                  //同步             synchronized (student) {                 Random random = new Random();                 int age = random.nextInt(100);                 student.setAge(age);                 System.out.println(currentThreadName + " is set age: " + age);                           System.out.println(currentThreadName + " is first get age: " + student.getAge() );                 try {                     Thread.sleep(500);                 } catch (InterruptedException e) {                     e.printStackTrace();                 }                 System.out.println(currentThreadName + " is second get age: " + student.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();         }     }

以上2中方法都实现的功能相同，但方法不一样 

ThreadLocal使用场合主要解决多线程中数据数据因并发产生不一致问题。ThreadLocal为每个线程的中并发访问的数据提供一个副本，通过访问副本来运行业务，这样的结果是耗费了内存，单大大减少了线程同步所带来性能消耗，也减少了线程并发控制的复杂度。

ThreadLocal不能使用原子类型（int，char...），只能使用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()方法获取要操作的数据，这样可以保证每个线程对应一个数据对象，在任何时刻都操作的是这个对象。

二.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更加复杂。