Java多线程之ThreadLocal

副标题#e#

ThreadLocal的焦点思想很简朴：为每个独立的线程提供一个变量的副本。

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

为了加深对ThreadLocal的领略，下面我利用一个例子来演示ThreadLocal如何断绝线程间的变量会见和修改：

【1】SerialNum类

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

#p#副标题#e#

可见第一个线程在挪用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);
    }

#p#分页标题#e#

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