彻底读懂ThreadLocal与Synchronized区别（代码案例详解）

一、案例学习

业务场景

• 需求：线程隔离- 在多线程并发的场景下，每个线程中的变量都是相互独立
• 线程A：设置（变量1）获取（变量1）
• 线程B：设置（变量2）获取（变量2）

多线程情况不使用同步机制

public class Demo {
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();

        for (int i = 0; i < 5; i++) {
            Thread t = new Thread() {
                @Override
                public void run() {
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("----------------");
                    System.out.println(Thread.currentThread().getName() + "-->" + demo.getContent());
                }
            };
            t.setName("线程" + i);
            t.start();
        }
    }
}

执行结果：出现线程安全问题（数据量少的情况下要多次测试，会出现线程安全问题）

----------------
线程0-->线程1的数据
----------------
线程1-->线程1的数据
----------------
线程2-->线程2的数据
----------------
线程3-->线程3的数据
----------------
线程4-->线程4的数据

使用同步锁synchronized

public class Demo {
    private String content;

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        for (int i = 0; i < 5; i++) {
            Thread t = new Thread() {
                @Override
                public void run() {
                    //加了锁的代码线程只能排队进行访问，失去了并发性
                    synchronized (Demo.class) {
                        demo.setContent(Thread.currentThread().getName() + "的数据");
                        System.out.println("----------------");
                        System.out.println(Thread.currentThread().getName() + "-->" + demo.getContent());
                    }
                }
            };
            t.setName("线程" + i);
            t.start();
        }

    }
}

执行结果：（可以增大循环次数多次测试）

----------------
线程0-->线程1的数据
----------------
线程1-->线程1的数据
----------------
线程2-->线程2的数据
----------------
线程3-->线程3的数据
----------------
线程4-->线程4的数据

 

public class MyDemo01 {
    ThreadLocal<String> t1 = new ThreadLocal<String>();

    //变量
    private String content;

    private String getContent() {
        //return content;
        return t1.get();
    }

    private void setContent(String content) {
        //this.content = content;
        //变量绑定到当前线程
        t1.set(content);
    }

    public static void main(String[] args) {
        MyDemo01 demo = new MyDemo01();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("----------------");
                    System.out.println(Thread.currentThread().getName() + "-->" + demo.getContent());
                }
            });
            thread.setName("线程" + i);
            thread.start();
        }
    }
}

执行结果：（可以增大循环次数多次测试）

----------------
线程0-->线程0的数据
----------------
线程1-->线程1的数据
----------------
线程2-->线程2的数据
----------------
线程3-->线程3的数据
----------------
线程4-->线程4的数据

ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。

---

二、对比小结

相同：ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

不同：Synchronized同步机制采用了“以时间换空间”的方式，仅提供一份变量，让不同的线程排队访问；而ThreadLocal采用了“以空间换时间”的方式，每一个线程都提供了一份变量，因此可以同时访问而互不影响。

📖 以时间换空间: 即枷锁方式，某个区域代码或变量只有一份节省了内存，但是会形成很多线程等待现象，因此浪费了时间而节省了空间。

📖 以空间换时间: 为每一个线程提供一份变量，多开销一些内存，但是呢线程不用等待，可以一起执行而相互之间没有影响。

---

☕️ 虽然ThreadLocal和Synchonized都用于解决多线程并发访问，ThreadLocal与synchronized还是有本质的区别。

📝 synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。

即Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。