Thread与ThreadLocal同步机制的比较

public class SequenceNumber {    private Integer integer = new Integer(0);    private static ThreadLocal<Integer> safeInteger = new ThreadLocal<Integer>(){        public Integer initialValue(){            return  0;        }    };    public int getThreadNext(){        safeInteger.set(safeInteger.get()+1);        return safeInteger.get();    }    public synchronized int getNext(){        this.integer++;        return this.integer;    }    private static class MyThreadSafe extends Thread{        private SequenceNumber sequenceNumber;        public MyThreadSafe(SequenceNumber s){            this.sequenceNumber = s;        }        public void run(){            for (int i = 0; i < 3; i++) {                try {                    Thread.sleep(20);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println("Thread["+Thread.currentThread().getName()+"]sn["+sequenceNumber.getThreadNext()+"]");            }        }    }    private static class MyThread extends Thread{        private SequenceNumber sequenceNumber;        public MyThread(SequenceNumber s){            this.sequenceNumber = s;        }        public void run(){            for (int i = 0; i < 3; i++) {                try {                    Thread.sleep(20);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println("Thread["+Thread.currentThread().getName()+"]sn["+sequenceNumber.getNext()+"]");            }        }    }    public static void main(String[] args) {//        test01();        test02();    }    public static void test01() {        SequenceNumber sequenceNumber = new SequenceNumber();        MyThreadSafe myThread1 = new MyThreadSafe(sequenceNumber);        MyThreadSafe myThread2 = new MyThreadSafe(sequenceNumber);        MyThreadSafe myThread3 = new MyThreadSafe(sequenceNumber);        myThread1.start();        myThread2.start();        myThread3.start();    }    public static void test02() {        SequenceNumber sequenceNumber = new SequenceNumber();        MyThread myThread1 = new MyThread(sequenceNumber);        MyThread myThread2 = new MyThread(sequenceNumber);        MyThread myThread3 = new MyThread(sequenceNumber);        myThread1.start();        myThread2.start();        myThread3.start();    }}

如上代码，test01使用的是ThreadLocal而test02使用的是synchronized。

test01输出：

Thread[Thread-1]sn[1]Thread[Thread-0]sn[1]Thread[Thread-2]sn[1]Thread[Thread-1]sn[2]Thread[Thread-0]sn[2]Thread[Thread-2]sn[2]Thread[Thread-1]sn[3]Thread[Thread-0]sn[3]Thread[Thread-2]sn[3]

test02输出：

Thread[Thread-0]sn[1]Thread[Thread-2]sn[3]Thread[Thread-1]sn[2]Thread[Thread-0]sn[4]Thread[Thread-1]sn[5]Thread[Thread-2]sn[6]Thread[Thread-0]sn[7]Thread[Thread-1]sn[8]Thread[Thread-2]sn[9]

ThreadLocal和线程同步机制相比有什么优势呢？ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。 

在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序缜密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。 

而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal为每一个线程提供一个独立的变量副本，从而隔离了多个线程对访问数据的冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的对象封装，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。 

由于ThreadLocal中可以持有任何类型的对象，低版本JDK所提供的get()返回的是Object对象，需要强制类型转换。但JDK 5.0通过泛型很好的解决了这个问题，在一定程度上简化ThreadLocal的使用，代码清单9-2就使用了JDK 5.0新的ThreadLocal<T>版本。 

概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式：访问串行化，对象共享化。而ThreadLocal采用了“以空间换时间”的方式：访问并行化，对象独享化。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。