Thread与ThreadLocal同步机制的比较

最新推荐文章于 2025-06-20 13:58:57 发布

原创最新推荐文章于 2025-06-20 13:58:57 发布 · 459 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线程 #ThreadLocal

本文探讨了ThreadLocal与线程同步机制在多线程环境下处理变量共享问题的不同方法。ThreadLocal通过为每个线程提供独立变量副本实现数据隔离，避免了同步所需的锁机制；而同步机制采用对象锁确保变量访问的串行化。文章通过具体代码示例展示了两种方法的输出差异及其实现原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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采用了“以空间换时间”的方式：访问并行化，对象独享化。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。