本次内容主要讲synchronized、volatile和ThreadLocal。

1、synchronized内置锁

　　线程开始运行，拥有自己的栈空间，就如同一个脚本一样，按照既定的代码一步一步地执行，直到终止。但是，每个运行中的线程，如果仅仅是孤立地运行，那么价值会很少，如果多个线程能够相互配合完成工作，包括数据之间的共享、协同处理事情。这将会带来巨大的价值。

　　Java支持多个线程同时访问一个对象或者对象的成员变量，关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性，又称为内置锁机制。synchronized使用的3种情况：

（1）用在实例方法上，此时锁住的是InstanceSyn这个类的实例对象，先来看正确的使用方式，每个线程持有的是同一个InstanceSyn实例。

  1. public class InstanceSyn {
  2.     private List<Integer> list = new ArrayList<>();
  3.  
  4.     public synchronized void instance() {
  5.         System.out.println(Thread.currentThread().getName() + " 调用instance()");
  6.         list.add(1);
  7.         try {
  8.             Thread.sleep(1000);
  9.         } catch (InterruptedException e) {
  10.             e.printStackTrace();
  11.         }
  12.         System.out.println(Thread.currentThread().getName() + " 结束instance()");
  13.     }
  14.  
  15.     static class InstanceSynTest extends Thread {
  16.         private InstanceSyn instanceSyn;
  17.         public InstanceSynTest(InstanceSyn instanceSyn) {
  18.             this.instanceSyn = instanceSyn;
  19.         }
  20.  
  21.         public void run() {
  22.             instanceSyn.instance();
  23.         }
  24.     }
  25.  
  26.     public static void main(String[] args) {
  27.         InstanceSyn instanceSyn = new InstanceSyn();
  28.         for (int i = 0; i < 3; i++) {
  29.             Thread thread = new InstanceSynTest(instanceSyn);
  30.             thread.start();
  31.         }
  32.     }
  33. }

可以看到3个线程按同步方式对instance()方法进行访问：

再看一下synchronized是怎么失效的，只是挪动了一行代码，此时3个线程持有的是不同的InstanceSyn实例，导致同步失效。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. public class InstanceSyn {
  5.     private List<Integer> list = new ArrayList<>();
  6.  
  7.     public synchronized void instance() {
  8.         System.out.println(Thread.currentThread().getName() + " 调用instance()");
  9.         list.add(1);
  10.         try {
  11.             Thread.sleep(1000);
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.         System.out.println(Thread.currentThread().getName() + " 结束instance()");
  16.     }
  17.  
  18.     static class InstanceSynTest extends Thread {
  19.         private InstanceSyn instanceSyn;
  20.  
  21.         public InstanceSynTest(InstanceSyn instanceSyn) {
  22.             this.instanceSyn = instanceSyn;
  23.         }
  24.  
  25.         public void run() {
  26.             instanceSyn.instance();
  27.         }
  28.     }
  29.  
  30.     public static void main(String[] args) {
  31.         for (int i = 0; i < 3; i++) {
  32.             InstanceSyn instanceSyn = new InstanceSyn();
  33.             Thread thread = new InstanceSynTest(instanceSyn);
  34.             thread.start();
  35.         }
  36.     }
  37. }

此时的输出：

（2）用在代码块上

① synchronized(this)，此时锁住的是InstanceSyn这个类的实例对象，和synchronized用在实例方法上原理一样，失效的情况也一样，这里就不具体演示了。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. public class InstanceSyn {
  5.     private List<Integer> list = new ArrayList<>();
  6.  
  7.     public void instance() {
  8.         //do something
  9.         synchronized (this) {
  10.             System.out.println(Thread.currentThread().getName() + " 开始访问同步块");
  11.             list.add(1);
  12.             try {
  13.                 Thread.sleep(1000);
  14.             } catch (InterruptedException e) {
  15.                 e.printStackTrace();
  16.             }
  17.             System.out.println(Thread.currentThread().getName() + " 结束访问同步块");
  18.         }
  19.         //do something
  20.     }
  21.  
  22.     static class InstanceSynTest extends Thread {
  23.         private InstanceSyn instanceSyn;
  24.  
  25.         public InstanceSynTest(InstanceSyn instanceSyn) {
  26.             this.instanceSyn = instanceSyn;
  27.         }
  28.  
  29.         public void run() {
  30.             instanceSyn.instance();
  31.         }
  32.     }
  33.  
  34.     public static void main(String[] args) {
  35.         InstanceSyn instanceSyn = new InstanceSyn();
  36.         for (int i = 0; i < 3; i++) {
  37.             Thread thread = new InstanceSynTest(instanceSyn);
  38.             thread.start();
  39.         }
  40.     }
  41. }

② 锁住一个静态对象，由于静态变量是属于整个类，不属于某个类的实例，全局唯一，所以就不会出现上面synchronized同步失效的情况。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. public class InstanceSyn {
  5.     private List<Integer> list = new ArrayList<>();
  6.  
  7.     private static Object object = new Object();
  8.  
  9.     public void instance() {
  10.         //do something
  11.         synchronized (object) {
  12.             System.out.println(Thread.currentThread().getName() + " 开始访问同步块");
  13.             list.add(1);
  14.             try {
  15.                 Thread.sleep(1000);
  16.             } catch (InterruptedException e) {
  17.                 e.printStackTrace();
  18.             }
  19.             System.out.println(Thread.currentThread().getName() + " 结束访问同步块");
  20.         }
  21.         //do something
  22.     }
  23.  
  24.     static class InstanceSynTest extends Thread {
  25.         private InstanceSyn instanceSyn;
  26.  
  27.         public InstanceSynTest(InstanceSyn instanceSyn) {
  28.             this.instanceSyn = instanceSyn;
  29.         }
  30.  
  31.         public void run() {
  32.             instanceSyn.instance();
  33.         }
  34.     }
  35.  
  36.     public static void main(String[] args) {
  37. //        InstanceSyn instanceSyn = new InstanceSyn();
  38.         for (int i = 0; i < 3; i++) {
  39.             InstanceSyn instanceSyn = new InstanceSyn();//尽管每个线程持有的不是同一个实例对象，但是由于锁住的是静态对象，所以也可以正确执行同步操作
  40.             Thread thread = new InstanceSynTest(instanceSyn);
  41.             thread.start();
  42.         }
  43.     }
  44. }
  1. 尽管每个线程持有的不是同一个实例对象，但是由于锁住的是静态对象，所以也可以正确执行同步操作。代码输出如下：

（3）用在静态方法上，此时锁住的是InstanceSyn这个类的Class对象，InstanceSyn的Class对象全局唯一，所以就算每个线程持有的InstanceSyn不一样，也可以进行同步访问操作。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. public class InstanceSyn {
  5.     private static List<Integer> list = new ArrayList<>();
  6.  
  7.     public static synchronized void instance() {
  8.         System.out.println(Thread.currentThread().getName() + " 调用instance()");
  9.         list.add(1);
  10.         try {
  11.             Thread.sleep(1000);
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.         System.out.println(Thread.currentThread().getName() + " 结束instance()");
  16.  
  17.     }
  18.  
  19.     static class InstanceSynTest extends Thread {
  20.         private InstanceSyn instanceSyn;
  21.  
  22.         public InstanceSynTest(InstanceSyn instanceSyn) {
  23.             this.instanceSyn = instanceSyn;
  24.         }
  25.  
  26.         public void run() {
  27.             instanceSyn.instance();
  28.         }
  29.     }
  30.  
  31.     public static void main(String[] args) {
  32. //        InstanceSyn instanceSyn = new InstanceSyn();
  33.         for (int i = 0; i < 3; i++) {
  34.             InstanceSyn instanceSyn = new InstanceSyn();//尽管每个线程持有的不是同一个实例对象，但是由于锁住的是类对象，所以也可以正确执行同步操作
  35.             Thread thread = new InstanceSynTest(instanceSyn);
  36.             thread.start();
  37.         }
  38.     }
  39. }

程序输出：

注：实例锁和类锁

　　实例锁是用于对象实例方法，类锁是用于类的静态方法上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个Class对象，所以不同对象实例的对象锁是互不干扰的。有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，类锁其实锁的是每个类的对应的Class对象。类锁和对象锁之间也是互不干扰的，下面用代码说明。

  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. public class InstanceSyn {
  5.     private static List<Integer> list = new ArrayList<>();
  6.  
  7.     private static Object object = new Object();
  8.  
  9.     public void instance() {
  10.         synchronized (object) {
  11.             System.out.println(Thread.currentThread().getName() + " 开始访问instance同步块");
  12.             list.add(1);
  13.             try {
  14.                 Thread.sleep(1000);
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.             System.out.println(Thread.currentThread().getName() + " 开始访问instance同步块");
  19.         }
  20.     }
  21.  
  22.     public void instance2() {
  23.         synchronized (this) {
  24.             System.out.println(Thread.currentThread().getName() + " 开始访问instance2同步块");
  25.             list.add(1);
  26.             try {
  27.                 Thread.sleep(1000);
  28.             } catch (InterruptedException e) {
  29.                 e.printStackTrace();
  30.             }
  31.             System.out.println(Thread.currentThread().getName() + " 开始访问instance2同步块");
  32.         }
  33.     }
  34.  
  35.     public static synchronized void instance3() {
  36.         System.out.println(Thread.currentThread().getName() + " 开始访问instance3同步块");
  37.         list.add(1);
  38.         try {
  39.             Thread.sleep(1000);
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         }
  43.         System.out.println(Thread.currentThread().getName() + " 开始访问instance3同步块");
  44.     }
  45.  
  46.     /**
  47.      * 调用锁静态对象的方法
  48.      */
  49.     static class InstanceSynTest extends Thread {
  50.         private InstanceSyn instanceSyn;
  51.  
  52.         public InstanceSynTest(InstanceSyn instanceSyn) {
  53.             this.instanceSyn = instanceSyn;
  54.         }
  55.  
  56.         public void run() {
  57.             instanceSyn.instance();
  58.         }
  59.     }
  60.  
  61.     /**
  62.      * 调用锁this的方法
  63.      */
  64.     static class InstanceSynTest2 extends Thread {
  65.         private InstanceSyn instanceSyn;
  66.  
  67.         public InstanceSynTest2(InstanceSyn instanceSyn) {
  68.             this.instanceSyn = instanceSyn;
  69.         }
  70.  
  71.         public void run() {
  72.             instanceSyn.instance2();
  73.         }
  74.     }
  75.  
  76.     /**
  77.      * 调用锁类对象的方法
  78.      */
  79.     static class InstanceSynTest3 extends Thread {
  80.         private InstanceSyn instanceSyn;
  81.  
  82.         public InstanceSynTest3(InstanceSyn instanceSyn) {
  83.             this.instanceSyn = instanceSyn;
  84.         }
  85.  
  86.         public void run() {
  87.             instanceSyn.instance3();
  88.         }
  89.     }
  90.  
  91.     public static void main(String[] args) {
  92.         InstanceSyn instanceSyn = new InstanceSyn();
  93.         Thread thread1 = new InstanceSynTest(instanceSyn);
  94.         Thread thread2 = new InstanceSynTest2(instanceSyn);
  95.         Thread thread3 = new InstanceSynTest3(instanceSyn);
  96.  
  97.         thread1.start();
  98.         thread2.start();
  99.         thread3.start();
  100.     }
  101. }

　　从程序输出可以看到，3个线程并没有同步访问。虽然这3个方法在同一个类中，但是由于3个方法锁住的对象不一样，所以他们之间互不干扰，不会进行同步访问。

2、 volatile　　

　　volatile保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。volatile底层采用了MESI缓存一致性协议来实现。M代表修改modify，E代表独占exclusive，S代表共享share，I代表失效invalid。下面画图进行说明。

E状态：独一份，且有效。在共享内存中有一个变量X，值是1。当只有一个线程把X读取到自己的工作内存中时，X处于独占状态，仅被1个线程持有。

S状态：每个线程工作内存中的变量值都是一样的。

M和I状态：一个线程修把X的值由1修改成5，是M状态；另外一个线程通过CPU总线嗅探机制得知X的值已经改变，使自己工作内存中X的值失效，是I状态。

下面用一段代码来演示volatile的用法。

  1. public class VolatileCase {
  2.     private volatile static boolean ready = false;
  3.     private static int number;
  4.  
  5.     private static class PrintThread extends Thread {
  6.         @Override
  7.         public void run() {
  8.             System.out.println("PrintThread is running.......");
  9.             while (!ready) {
  10.  
  11.             }
  12.             System.out.println("number = " + number);
  13.         }
  14.     }
  15.  
  16.     public static void main(String[] args) {
  17.         new PrintThread().start();
  18.         try {
  19.             Thread.sleep(3000);
  20.         } catch (InterruptedException e) {
  21.             e.printStackTrace();
  22.         }
  23.         number = 51;
  24.         ready = true;
  25.         try {
  26.             Thread.sleep(3000);
  27.         } catch (InterruptedException e) {
  28.             e.printStackTrace();
  29.         }
  30.         System.out.println("main is ended!");
  31.     }
  32. }

　　从程序执行情况可以看出，主线程在执行3秒后，PrintThread线程得知ready状态变成true，迅速退出循环。不加volatile关键字时，PrintThread线程无法得知ready状态变成true，从而不会退出循环。

　　刚刚演示的是volatile修饰一个简单变量，那么volatile来修饰一个复杂对象的时候又是什么样的呢？我们通过代码来测试，定义一个Entity类和一个测试类。

  1. public class VolatileEntity {int first = 0;
  2.     int first = 0;
  3.  
  4.     private static class VolatileEntityInstance {
  5.         private static VolatileEntity instance = new VolatileEntity();
  6.     }
  7.  
  8.     public static VolatileEntity getInstance() {
  9.         return VolatileEntityInstance.instance;
  10.     }
  11. }
  1.  public class VolatileEntityTest {
  2.      private volatile static VolatileEntity volatileEntity = VolatileEntity.getInstance();
  3.  
  4.      public static void main(String args[]) {
  5.          //读线程
  6.          new Thread(() -> {
  7.              int localValue = volatileEntity.first;
  8.              while (localValue < 3) {
  9.                  if (volatileEntity.first != localValue) {
  10.                      System.out.printf("first is update to [%d]\n", volatileEntity.first);
  11.                      localValue = volatileEntity.first;
  12.                  }
  13.              }
  14.          }, "read").start();
  15.  
  16.          //写线程
  17.          new Thread(() -> {
  18.              int localValue = volatileEntity.first;
  19.              while (localValue < 3) {
  20.                  System.out.printf("first will be changed to [%d]\n", ++localValue);
  21.                  volatileEntity.first = localValue;
  22.                  try {
  23.                      Thread.sleep(1);
  24.                  } catch (InterruptedException e) {
  25.                      e.printStackTrace();
  26.                  }
  27.              }
  28.          }, "write").start();
  29.      }
  30.  }

运行代码可以输出以下信息：

　　可以看到first字段在一个线程发生改变时，另外一个线程可以检测到它发生的变化。可以认为volatile修饰的对象，对象里面的每一个字段也被volatile修饰了。再看看使用volatile修饰数组的情况。

  1. public class VolatileArray {
  2.     static volatile int[] array = new int[]{0, 0};
  3.  
  4.     public static void main(String args[]) {
  5.         //读线程
  6.         new Thread(() -> {
  7.             int localValue = 0;
  8.             while (true) {
  9.                 if (array[0] > localValue) {
  10.                     System.out.printf("array[0] is update to [%d]\n", array[0]);
  11.                     localValue = array[0];
  12.                 }
  13.             }
  14.         }, "read").start();
  15.  
  16.         //写线程
  17.         new Thread(() -> {
  18.             for (int i = 1; i <= 5; i++) {
  19.                 System.out.printf("array[0] will be changed to [%d]\n", i);
  20.                 array[0] = i;
  21.                 try {
  22.                     Thread.sleep(1);
  23.                 } catch (InterruptedException e) {
  24.                     e.printStackTrace();
  25.                 }
  26.             }
  27.         }, "write").start();
  28.     }
  29. }

程序输出：

如果把修饰数组的volatile关键字去掉，再次执行程序输出如下：

由此可以得出一个结论，volatile修饰的数组，可以看作是对其中每一个元素使用了volatile关键字。

注：volatile不能保证原子性，多个线程同时写会造成数据不安全问题，下面使用例子说明。

  1. public class VolatileNotSafe {
  2.     private volatile long count = 0;
  3.  
  4.     public long getCount() {
  5.         return count;
  6.     }
  7.  
  8.     public void setCount(long count) {
  9.         this.count = count;
  10.     }
  11.  
  12.     public void increase() {
  13.         count++;
  14.     }
  15.  
  16.     //工作线程
  17.     private static class CountIncrease extends Thread {
  18.         private VolatileNotSafe volatileNotSafe;
  19.  
  20.         public CountIncrease(VolatileNotSafe volatileNotSafe) {
  21.             this.volatileNotSafe = volatileNotSafe;
  22.         }
  23.  
  24.         @Override
  25.         public void run() {
  26.             for (int i = 0; i < 10000; i++) {
  27.                 volatileNotSafe.increase();
  28.             }
  29.         }
  30.     }
  31.  
  32.     public static void main(String[] args) throws InterruptedException {
  33.         VolatileNotSafe volatileNotSafe = new VolatileNotSafe();
  34.         for (int i = 0; i < 5; i++) {
  35.             CountIncrease counter = new CountIncrease(volatileNotSafe);
  36.             counter.start();
  37.         }
  38.         Thread.sleep(2000);
  39.         System.out.println(volatileNotSafe.count);
  40.     }
  41. }

程序说明：启动5个线程对共享数据count进行一个累加操作，每个线程累加1万次。线程安全情况下，count的输出应该是50000。来看看这段代的输出：

多次运行这段代码，可以看到count的结果是小于等于50000，所以volatile不能保证数据在多个线程下同时写的线程安全，具体原因后面单独介绍。

3、ThreadLocal

　　ThreadLocal和synchronized都用于解决多线程并发访问，但是他们之间有本质的区别。synchronized是利用锁机制，使方法或代码块在同一时间只能由一个线程访问，其他没有抢到锁的线程处于阻塞状态。而ThreadLocal为每个线程都提供了变量的副本，使得每个线程在某一时间访问到的是不同的对象，这样就隔离了多个线程对数据的共享。看一下TheadLocal的实现，先上一张图。

　　简单的对图做一个说明：在Thread这个类中，有一个ThreadLocalMap的成员变量，ThreadLocalMap这个类是ThreadLocal的一个内部类。ThreadLocalMap中有一个Entry数组用来保存数据，因为可能有多个变量需要线程隔离访问。Entry这个类类似于map的key-value结构，key就是ThreadLocal，value是需要隔离访问的变量。再通过源码看看，看下ThreadLocal最常用方法：

  1. public class ThreadLocal<T> {
  2.  
  3.  public T get() {
  4.         Thread t = Thread.currentThread();
  5.         ThreadLocalMap map = getMap(t);
  6.         if (map != null) {
  7.             ThreadLocalMap.Entry e = map.getEntry(this);
  8.             if (e != null) {
  9.                 @SuppressWarnings("unchecked")
  10.                 T result = (T)e.value;
  11.                 return result;
  12.             }
  13.         }
  14.         return setInitialValue();
  15.     }
  16.  
  17.  public void set(T value) {
  18.         Thread t = Thread.currentThread();
  19.         ThreadLocalMap map = getMap(t);
  20.         if (map != null)
  21.             map.set(this, value);
  22.         else
  23.             createMap(t, value);
  24.     }
  25.  
  26.   public void remove() {
  27.          ThreadLocalMap m = getMap(Thread.currentThread());
  28.          if (m != null)
  29.              m.remove(this);
  30.      }
  31.  
  32.  protected T initialValue() {
  33.         return null;
  34.     }
  35. }

　　get()方法返回当前线程所对应的线程局部变量；set()方法设置当前线程的线程局部变量的值；remove()方法将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。需要指出的是，当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。initialValue()方法返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。具体的实现原理在这里不详细展开，后面单独介绍。下面用代码演示下ThreadLocal的用法：

  1. public class UseThreadLocal {
  2.     static ThreadLocal<String> threadLocal = new ThreadLocal<>();
  3.  
  4.     public static class TestThread implements Runnable {
  5.         int id;
  6.  
  7.         public TestThread(int id) {
  8.             this.id = id;
  9.         }
  10.  
  11.         public void run() {
  12.             threadLocal.set("线程-" + id);
  13.             System.out.println(Thread.currentThread().getName() + "的threadLocal ：" + threadLocal.get());
  14.             threadLocal.remove();
  15.         }
  16.     }
  17.  
  18.     public static void main(String[] args) throws InterruptedException {
  19.         for (int i = 0; i < 3; i++) {
  20.             new Thread(new TestThread(i)).start();
  21.         }
  22.         Thread.sleep(5);
  23.     }
  24. }

这段代码的main()方法中启动了3个线程，分别给threadLocal变量赋值，程序输出的结果不一样，可以看出每个线程对threadLocal变量是隔离访问的。

注：使用ThreadLocal的坑

看下面代码：

  1. public class ThreadLocalUnSafe implements Runnable {
  2.     private static class Number {
  3.         private int number;
  4.  
  5.         public Number(int number) {
  6.             this.number = number;
  7.         }
  8.  
  9.         public int getNumber() {
  10.             return number;
  11.         }
  12.  
  13.         public void setNumber(int num) {
  14.             this.number = num;
  15.         }
  16.  
  17.         @Override
  18.         public String toString() {
  19.             return "Number [number=" + number + "]";
  20.         }
  21.     }
  22.  
  23.     public static Number number = new Number(0);
  24.     public static ThreadLocal<Number> threadLocal = new ThreadLocal<>();
  25.  
  26.     public void run() {
  27.         threadLocal.set(number);
  28.         Number numberInner = threadLocal.get();
  29.         numberInner.setNumber(numberInner.getNumber() + 1);//每个线程计数加一
  30.         try {
  31.             Thread.sleep(2); //休眠2毫秒，模拟实际业务
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         }
  35.         System.out.println(Thread.currentThread().getName() + "=" + threadLocal.get().getNumber());
  36.     }
  37.  
  38.     public static void main(String[] args) {
  39.         for (int i = 0; i < 5; i++) {
  40.             new Thread(new ThreadLocalUnSafe()).start();
  41.         }
  42.         try {
  43.             Thread.sleep(10); //休眠10毫秒，保证5个线程全部启动
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         }
  47.     }
  48. }

main()方法中启动5个线程，每个线程对Number对象中的number字段加1，number默认为0，所以每个线程输出的number应该是1。看看实际输出：

　　纳尼！！！怎么跟我想的不是一个东西~~~怎么全部变成5了。难道他们没有独自保存自己的Number副本吗？为什么其他线程还是能够修改这个值？仔细考察ThreadLocal的代码，我们发现ThreadLocalMap中保存的其实是对象的一个引用，这样的话，当有其他线程对这个引用指向的对象实例做修改时，其实也同时影响了所有的线程持有的对象引用所指向的同一个对象实例。这也就是为什么上面的程序为什么会输出一样的结果，5个线程中保存的是同一Number对象的引用，在线程睡眠的时候，其他线程将number变量进行了修改，而修改的对象Number的实例是同一份，因此它们最终输出的结果是相同的。

　　想要上面的程序正常工作，其实也非常简单，用法是让每个线程的ThreadLocal持有不同的Number对象，使用刚刚提到的initialValue()方法即可，代码如下：

  1. public class ThreadLocalUnSafe implements Runnable {
  2.     private static class Number {
  3.         private int number;
  4.  
  5.         public Number(int number) {
  6.             this.number = number;
  7.         }
  8.  
  9.         public int getNumber() {
  10.             return number;
  11.         }
  12.  
  13.         public void setNumber(int num) {
  14.             this.number = num;
  15.         }
  16.  
  17.         @Override
  18.         public String toString() {
  19.             return "Number [number=" + number + "]";
  20.         }
  21.     }
  22.  
  23.     //重写initialValue()方法
  24.     public static ThreadLocal<ThreadLocalUnSafe.Number> threadLocal = new ThreadLocal<ThreadLocalUnSafe.Number>() {
  25.         @Override
  26.         protected ThreadLocalUnSafe.Number initialValue() {
  27.             return new ThreadLocalUnSafe.Number(0);
  28.         }
  29.     };
  30.  
  31.     public void run() {
  32.         Number numberInner = threadLocal.get();
  33.         numberInner.setNumber(numberInner.getNumber() + 1);//每个线程计数加一
  34.         try {
  35.             Thread.sleep(2); //休眠2毫秒，模拟实际业务
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         }
  39.         System.out.println(Thread.currentThread().getName() + "=" + threadLocal.get().getNumber());
  40.     }
  41.  
  42.     public static void main(String[] args) {
  43.         for (int i = 0; i < 5; i++) {
  44.             new Thread(new ThreadLocalUnSafe()).start();
  45.         }
  46.         try {
  47.             Thread.sleep(10); //休眠10毫秒，保证5个线程全部启动
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52. }

执行代码，输出的是我们想要的结果，上面的坑成功填平。

线程之间的协作在下一篇文章中介绍，在阅读过程中如发现描述有误，请指出，谢谢。

java线程间的共享的更多相关文章

  1. Java 线程间通讯（共享变量方式）

    Java线程间通讯,最常用的方式便是共享变量方式,多个线程共享一个静态变量就可以实现在线程间通讯,但是这需要注意的就是线程同步问题. 一.没考虑线程同步: package com.wyf; publi ...

  2. 说说Java线程间通信

    序言 正文 [一] Java线程间如何通信? 线程间通信的目标是使线程间能够互相发送信号,包括如下几种方式: 1.通过共享对象通信 线程间发送信号的一个简单方式是在共享对象的变量里设置信号值:线程A在 ...

  3. 说说 Java 线程间通信

    序言 正文 一.Java线程间如何通信? 线程间通信的目标是使线程间能够互相发送信号,包括如下几种方式: 1.通过共享对象通信 线程间发送信号的一个简单方式是在共享对象的变量里设置信号值:线程A在一个 ...

  4. Java线程间通信-回调的实现方式

    Java线程间通信-回调的实现方式   Java线程间通信是非常复杂的问题的.线程间通信问题本质上是如何将与线程相关的变量或者对象传递给别的线程,从而实现交互.   比如举一个简单例子,有一个多线程的 ...

  5. 深入学习c++--多线程编程（二）【当线程间需要共享非const资源】

    1. 遇到的问题 #include <iostream> #include <thread> #include <chrono> #include <futu ...

  6. 【JAVA线程间通信技术】

    之前的例子都是多个线程执行同一种任务,下面开始讨论多个线程执行不同任务的情况. 举个例子:有个仓库专门存储货物,有的货车专门将货物送往仓库,有的货车则专门将货物拉出仓库,这两种货车的任务不同,而且为了 ...

  7. Java线程间通信之wait/notify

    Java中的wait/notify/notifyAll可用来实现线程间通信,是Object类的方法,这三个方法都是native方法,是平台相关的,常用来实现生产者/消费者模式.我们来看下相关定义: w ...

  8. Java线程间和进程间通信

    1 线程与线程间通信 1.1 基本概念以及线程与进程之间的区别联系 关于进程和线程,首先从定义上理解就有所不同: 进程是具有一定独立功能的程序.它是系统进行资源分配和调度的一个独立单位,重点在系统调度 ...

  9. JMM之Java线程间通讯——等待通知机制及其经典范式

    在并发编程中,实际处理涉及两个关键问题:线程之间如何通信及线程之间如何同步(这里的线程是指并发执行的活动实体). 通信是指线程之间以何种机制来交换信息.在共享内存的并发模型里,线程之间共享程序的公共状 ...

随机推荐

  1. Java面试题4-附答案

    BIO.NIO和AIO的区别   Java BIO : 同步并阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程 ...

  2. Qt 线程池QThreadPool类、QRunnable类

    QThreadPool类 用来管理 QThreads.此类中的所有函数都是线程安全的. 主要属性: 1.activeThreadCount: 此属性表示线程池中的活动线程数,通过activeThrea ...

  3. nonparametric method|One-Mean t-Interval Procedure|

    8.4 Confidence Intervals for One Population Mean When σ Is Unknown 原先是 standardized version of x bar ...

  4. axious设置携带cookie同时允许跨域的问题

    axious设置携带cookie同时允许跨域的问题

  5. 接口测试 requests的身份认证方式

    requests提供多种身份认证方式,包括基本身份认证.netrc 认证.摘要式身份认证.OAuth 1 认证.OAuth 2 与 OpenID 连接认证.自定义认证.这些认证方式的应用场景是什么呢? ...

  6. 华为OD两轮技术面试

    华为OD面试1性格测试选积极向上的选项,注意,性格测试也会挂人,我一个朋友性格测试就没过.2机试 一道变成题目 1h 用例60%通过即可任给一个数组,元素有20M,1T,300G之类的,其中1T=10 ...

  7. PowerDesign15连接数据库并反向表结构详细

    10.0 sql2008 11.0 sql2010 这的服务器名称,复制到上面 这里的默认数据库不要改.Powerdesign会把自已的数据也存在默认的数据库里 一般不用改 测试 成功 这里ODBC的 ...

  8. Eclipse 配置Android 开发环境

    1.eclipse安装ADT插件. 地址:http://dl-ssl.google.com/android/eclipse/ 2.安装成功后,提示重启.重新启动后弹出android sdk 的路径选择 ...

  9. 3DMAX卸载/完美解决安装失败/如何彻底卸载清除干净3DMAX各种残留注册表和文件的方法

    在卸载3dmax重装3dmax时发现安装失败,提示是已安装3dmax或安装失败.这是因为上一次卸载3dmax没有清理干净,系统会误认为已经安装3dmax了.有的同学是新装的系统也会出现3dmax安装失 ...

  10. Struts2开发基本步骤

    1 加载jar文件   commons-fileupload.jar   commons-io.jar   commons-lang.jar   freemaker.jar   ognl.jar   ...