线程范围内的共享变量是指对同一个变量，几个线程同时对它进行写和读操作，而同一个线程读到的数据就是它自己写进去的数据。
1、未实现变量共享的demo：
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
package com.model.elgin.thread;
import java.util.Random; public class NotSharedVarThread { private static int data; public static void main(String[] args) { for (int i = 0; i < 2; i++) { new Thread(new Runnable() { @Override public void run() { data=new Random().nextInt(10000); System.out.println(Thread.currentThread().getName() + "将data修改为：" +data); new A().get(); new B().get(); } }).start(); } } static class A{ public void get(){ System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data); } } static class B{ public void get(){ System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data); } } } |
运行结果：
从结果可以看出，线程0将线程1修改后的data值覆盖了，并且输出的结果是线程1中修改的值。
那么该如何来解决这个问题呢？
2、线程范围内变量共享的实现方式：
一、通过线程的同步互斥实现
使用同步代码块，将变量修改以及访问的代码加锁，线程0访问结束才允许线程1来修改data的值，代码如下：
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
package com.model.elgin.thread;
import java.util.Random; public class NotSharedVarThread { private static int data; public static void main(String[] args) { for (int i = 0; i < 2; i++) { new Thread(new Runnable() { @Override public void run() { synchronized (NotSharedVarThread.class) { data=new Random().nextInt(10000); System.out.println(Thread.currentThread().getName() + "将data修改为：" +data); new A().get(); new B().get(); } } }).start(); } } static class A{ public void get(){ System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data); } } static class B{ public void get(){ System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data); } } } |
运行结果：
从结果可以看出，线程1结束之后线程0才开始修改data的值。
二、通过Map的key/value键值对，将线程与其对应的数据绑定
通过Map的特性，将key为当前线程，value为对应的值。
测试代码：
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
package com.model.elgin.thread;
import java.util.HashMap; import java.util.Map; import java.util.Random; public class NotSharedVarThread { private static Map<Thread,Integer> data=new HashMap<Thread, Integer>(); public static void main(String[] args) { for (int i = 0; i < 2; i++) { new Thread(new Runnable() { @Override public void run() { int value=new Random().nextInt(10000); data.put(Thread.currentThread(),value); System.out.println(Thread.currentThread().getName()+"将data中的值修改为：" + value); new A().get(); new B().get(); } }).start(); } } static class A{ public void get(){ System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data.get(Thread.currentThread())); } } static class B{ public void get(){ System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data.get(Thread.currentThread())); } } } |
运行结果：
三、通过ThreadLocal实现：
ThreaLocal类在维护变量时，实际使用了当前线程（Thread）中的一个叫做 ThreadLocalMap的独立副本（Thread的成员变量），每个线程可以独立的修改属于自己的副本而不会相互影响，从而实现了线程之间的隔离，避免了线程访问实例变量发生冲突的问题。
示例代码：
|
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
package com.model.elgin.thread;
import java.util.HashMap; import java.util.Map; import java.util.Random; public class NotSharedVarThread { private static ThreadLocal<Integer> data=new ThreadLocal<Integer>(); public static void main(String[] args) { for (int i = 0; i < 2; i++) { new Thread(new Runnable() { @Override public void run() { int value=new Random().nextInt(10000); data.set(value); System.out.println(Thread.currentThread().getName()+"将线程对应的value保存到ThreadLocal对象中" + value); new A().get(); new B().get(); } }).start(); } } static class A{ public void get(){ System.out.println(Thread.currentThread().getName() + "-A类中data的值为：" + data.get()); } } static class B{ public void get(){ System.out.println(Thread.currentThread().getName() + "-B类中data的值为：" + data.get()); } } } |
运行结果：
3、小结
1） ThreadLocal是一个Java类，通过对当前线程中局部变量的操作来解决不同线程的访问变量的冲突问题。所以，ThreadLocal提供了线程安全的共享机制，每个线程都拥有各自的副本（ThreadLocalMap实例）
2） Java中的synchronized是一个关键字，它依靠JVM的锁机制来实现临界区的函数或者变量在访问时的原子性。在同步机制中，通过对象的锁机制来保证同一时刻只有一个线程访问变量。
同步机制采取了以“以时间换空间”的方式，提供一个变量，让线程排队访问。而ThreadLocal则是采用了以“空间换取时间”的方式，为每一个线程都提供一份变量副本，从而实现同时访问而互不影响。