Java多线程之ThreadLocal

 ThreadLocal的核心思想很简单：为每个独立的线程提供一个变量的副本。

        Java提供的synchronized关键字使用了“同步锁”的机制来阻止线程的竞争访问，即“以时间换空间”。: " 10pt; FONT-SIZE:>    ThreadLocal则使用了“拷贝副本”的方式，人人有份，你用你的，我用我的，大家互不影响，是“以空间换时间”。每个线程修改变量时，实际上修改的是变量的副本，不怕影响到其它线程。

        为了加深对ThreadLocal的理解，下面我使用一个例子来演示ThreadLocal如何隔离线程间的变量访问和修改：

【1】SerialNum类

       可以看到ThreadLocal在内部维护了一个Map，将变量的值和线程绑定起来，get/set方法都是对该线程对应的value进行操作，所以不会影响到其它线程。

package  example.thread.threadLocal;

public   class  SerialNum {

     private   static   int  nextSerialNum  =   1 ;

    @SuppressWarnings( " unchecked " )
     private   static  ThreadLocal serialNum  =   new  ThreadLocal() {
         protected synchronized Object initialValue() {
            return new Integer(nextSerialNum++);      
        }                                                           
    };

     public   static   int  get() {
         return  ((Integer) (serialNum.get())).intValue();
    }
    
    @SuppressWarnings( " unchecked " )
     public   static   void  set(Integer newSerial){
        serialNum.set(newSerial);
    }
}

【2】GetSerialNumThread

package  example.thread.threadLocal;

public   class  GetSerialNumThread  implements  Runnable {

     public   static   void  main(String args[]) {

        GetSerialNumThread serialNumGetter  =   new  GetSerialNumThread();
        Thread t1  =   new  Thread(serialNumGetter,  " Thread A " );
        Thread t2  =   new  Thread(serialNumGetter,  " Thread B " );
        t1.start();
         try  {
            t1.join();
        }  catch  (InterruptedException e) {
            e.printStackTrace();
        }    
        t2.start();            
    }

     public   void  run() {
         int mySerialNum = getSerialNum();
        System.out.println( " 线程  "   +  Thread.currentThread().getName()
                 +   "  获取到的序列号是 "   +  mySerialNum);
        System.out.println( " 线程  "   +  Thread.currentThread().getName()
                 +   "  修改了序列号为 "   +  (mySerialNum  *   3 ));
        setSerialNum(mySerialNum * 3);
        System.out.println( " 线程  "   +  Thread.currentThread().getName()
                 +   "  再次获得的序列号是 "   +  getSerialNum());
    }

     private   int  getSerialNum() {
         return  SerialNum.get();
    }

     private   void  setSerialNum( int  newSerialNum) {
        SerialNum.set( new  Integer(newSerialNum));
    }
}

运行的结果如下：

线程 Thread A 获取到的序列号是1
线程 Thread A 修改了序列号为3
线程 Thread A 再次获得的序列号是3
线程 Thread B 获取到的序列号是2
线程 Thread B 修改了序列号为6
线程 Thread B 再次获得的序列号是6

       可见第一个线程在调用SerialNum.set(int)方法修改static变量时，其实修改的是它自己的副本，而不是修改本地变量，第二个线程在初始化的时候拿到的序列号是2而不是7。

       为什么会这样呢？明明serialNum是静态变量啊？其实我们只需要看看ThreadLocal的内部构造就知道了：

A. ThreadLocal的get()方法：

  /**
     * Returns the value in the current thread's copy of this thread-local
     * variable.  Creates and initializes the copy if this is the first time
     * the thread has called this method.
     *
     *  @return  the current thread's value of this thread-local
      */
     public  T get() {
        Thread t  =  Thread.currentThread();
        ThreadLocalMap map  =  getMap(t);
         if  (map  !=   null )
             return  (T)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.
        T value  =  initialValue();
        createMap(t, value);
         return  value;
    }

B. ThreadLocal的set()方法：

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Many applications will have no need for
     * this functionality, relying solely on the { @link  #initialValue}
     * method to set the values of thread-locals.
     *
     *  @param  value the value to be stored in the current threads' copy of
     *        this thread-local.
      */
     public   void  set(T value) {
        Thread t  =  Thread.currentThread();
        ThreadLocalMap map  =  getMap(t);
         if  (map  !=   null )
            map.set( this , value);
         else
            createMap(t, value);
    }