本文主要介绍Java多线程中的同步，也就是如何在Java语言中写出线程安全的程序，如何在Java语言中解决非线程安全的相关问题。阅读本文应该着重掌握如下技术点：

  1. synchronized对象监视器为Object时的使用。
  2. synchronized对象监视器为Class时的使用。
  3. 非线程安全是如何出现的。
  4. 关键字volatile的主要作用。
  5. 关键字volatile与synchronized的区别及使用情况。

1.synchronized同步方法

“非线程安全”其实会在多个线程对同一个对象中的实例变量进行并发访问时发生，产生的后果就是”脏读“，也就是读取到的数据其实是被更改过的。而“线程安全”就是已获得的实例变量的值是经过线程同步处理的，不会出现脏读的现象。

1.1 方法内的变量为线程安全

“非线程安全”问题存在于“实例变量”中，如果是方法内部的私有变量，则不存在“非线程安全”问题，所得结果也就是“线程安全”的了。

1.2 实例变量的非线程安全

如果多个线程共同访问1个对象中的实例变量，则有可能出现“非线程安全”问题。

用线程访问的对象中如果有多个实例对象，则运行的结果有可能出现交叉的情况。

如果对象仅有一个实例变量，则有可能出现覆盖的情况。

如果两个线程同时访问一个没有同步的方法，如果两个线程同时操作业务对象中的实例变量，则有可能出现“非线程安全”问题。解决这个问题的方法就是在方法前加关键字synchronized即可。

1.3 多个对象多个锁

代码示例：

  1. public class Run {
  2.     public static void main(String[] args) {
  3.         MyService service1 = new MyService();
  4.         Thread thread1 = new Thread(service1);
  5.         thread1.start();
  6.         MyService service2 = new MyService();
  7.         Thread thread2 = new Thread(service2);
  8.         thread2.start();
  9.     }
  10. }
  11. public class MyService implements Runnable {
  12.     private int i = 0;
  13.     @Override
  14.     synchronized public void run() {
  15.         System.out.println(++i);
  16.     }
  17. }

上面示例是两个线程分别访问同一个类的两个不同实例的相同的同步方法，效果却是以异步的方式运行的。本示例由于创建了2个业务对象，在系统中产生出2个锁，所以运行结果是异步的，打印的效果就是1 1。当我们把线程2的参数service2改成service1，打印结果变为1 2。为什么是这样的结果？

关键字 synchronized 取得的线程对象都是对象锁，而不是把一段代码或方法（函数）当做锁，所以在上面的示例中，哪个线程先执行带 synchronized 关键字的方法，哪个线程就持有该方法所属对象的锁Lock，那么其他线程只能呈等待状态，前提是多个线程访问的是同一个对象。

但如果多个线程访问多个对象，则JVM会创建多个锁。

1.4 synchronized方法与锁对象

为了证明前面讲的线程锁是对象，示例代码如下：

  1. public class MyService implements Runnable {
  2.     @Override
  3.     public void run() {
  4.         System.out.println("begin: "+Thread.currentThread().getName());
  5.         try {
  6.             Thread.sleep(5000);
  7.         } catch (InterruptedException e) {
  8.             e.printStackTrace();
  9.         }
  10.         System.out.println("end");
  11.     }
  12. }
  13. public class Run {
  14.     public static void main(String[] args) {
  15.         MyService service = new MyService();
  16.         Thread thread1 = new Thread(service,"A");
  17.         thread1.start();
  18.         Thread thread2 = new Thread(service,"B");
  19.         thread2.start();
  20.     }
  21. }

运行结果：

  1. begin: B
  2. begin: A
  3. end
  4. end

在run方法前加入关键字synchronized进行同步处理。再次运行结果如下：

  1. begin: A
  2. end
  3. begin: B
  4. end

通过上面的实验得出结论，调用关键字synchronized声明的方法一定是排队运行的。另外需要牢牢记住“共享”这两个字，只有共享资源读写访问才需要同步化，如果不是共享资源，那么基本就没有同步的必要。

1.5 脏读

  1. public class MyService{
  2.     private String username = "AA";
  3.     private String password = "aa";
  5.     public void getValue() {
  6.         System.out.println(Thread.currentThread().getName()+" : "+username+" "+password);
  7.     }
  9.     synchronized public void setValue(String username,String password){
  10.         this.username = username;
  11.         try {
  12.             Thread.sleep(1000);
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  16.         this.password = password;
  17.     }
  19.     public static void main(String[] args) throws InterruptedException {
  20.         MyService service = new MyService();
  21.         Thread thread1 = new Thread(() -> service.setValue("BB","bb"),"Thread-A");
  22.         thread1.start();
  23.         Thread.sleep(200);
  24.         Thread thread2 = new Thread(service::getValue,"Thread-B");
  25.         thread2.start();
  26.     }
  27. }

打印结果：

  1. Thread-B : BB aa

出现脏读是因为getValue方法不是同步的，所以可以在任意时候进行调用。解决方法就是加上同步synchronized关键字，代码如下：

  1. synchronized public void getValue() {
  2.    System.out.println(Thread.currentThread().getName()+" : "+username+" "+password);
  3. }

运行结果：

  1. Thread-B : BB bb

通过上述示例不仅要知道脏读是通过synchronized关键字解决的，还要知道如下内容：

当A线程调用实例对象的加入synchronized关键字的 X 方法时，A线程就获得了 X 方法锁，更准确地讲，是获得了对象的锁，所以其他线程必须等A线程执行完毕了才可以调用 X 方法，但B线程可以随意调用其他的非 synchronized 同步方法。

脏读一定会出现操作实例变量的情况下，这就是不同线程“争抢”实例变量的结果。

1.6 synchronized锁重入

关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象后，再次请求此对象锁时是可以再次得到该对象的锁的。这也证明了在一个synchronized方法/块的内部调用本类的其他synchronized方法/块，是永远可以得到锁的。

示例代码：

  1. public class MyService{
  2.     synchronized public void service1(){
  3.         System.out.println("service1");
  4.         service2();
  5.     }
  7.     synchronized public void service2(){
  8.         System.out.println("service2");
  9.     }
  10. }

“可重入锁”的概念是：自己可以再次获取自己的内部锁。可重入锁也支持在父子类继承的环境中。

示例代码：

  1. public class MyServiceChild extends MyService{
  2.     synchronized public void service(){
  3.         System.out.println("service1");
  4.         this.service2();
  5.     }
  6. }

说明子类是完全可以通过“可重入锁”调用父类的同步方法的。

1.7 出现异常,锁自动释放

当一个线程执行的代码出现异常时，其所持有的锁会自动释放。

1.8 同步不具有继承性

同步不可以继承。子类继承父类的同步方法时还需要添加synchronized关键字才能保持同步。

2.synchronized同步语句块

用关键字synchronized声明方法在某些情况下是有弊端的，比如A线程调用同步方法执行一个长时间的任务，那么B线程则必须等待比较长的时间。在这样的情况下可以使用synchronized同步语句块来解决。synchronized 方法是对当前对象进行加锁，而 synchronized代码块是对某一个对象进行加锁。

2.1 synchronized同步代码块的使用

当两个并发线程访问同一个对象object中的synchronized(this)同步代码块时，一段时间内只能有一个线程被执行，另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

示例代码：

  1. public class Test {
  3.     public void service(){
  4.         synchronized (this) {
  5.             System.out.println(Thread.currentThread().getName()+" begin: " + System.currentTimeMillis());
  6.             try {
  7.                 Thread.sleep(3000);
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.             System.out.println(Thread.currentThread().getName()+" end: " + System.currentTimeMillis());
  12.         }
  13.     }
  14.     public static void main(String[] args) {
  15.         Test test = new Test();
  16.         new Thread(new Runnable() {
  17.             @Override
  18.             public void run() {
  19.                 test.service();
  20.             }
  21.         },"Thread-A").start();
  22.         new Thread(new Runnable() {
  23.             @Override
  24.             public void run() {
  25.                 test.service();
  26.             }
  27.         },"Thread-B").start();
  28.     }
  29. }

运行结果：

  1. Thread-A begin: 1537000799741
  2. Thread-A end: 1537000802742
  3. Thread-B begin: 1537000802742
  4. Thread-B end: 1537000805742

上述示例证明了同步synchronized代码块真的是同步的。

2.2 一半同步，一半异步

我们把前面的示例代码的service方法改造一下：

  1.     public void service(){
  2.         System.out.println(Thread.currentThread().getName()+" begin: " + System.currentTimeMillis());
  3.         synchronized (this) {
  4.             try {
  5.                 Thread.sleep(3000);
  6.             } catch (InterruptedException e) {
  7.                 e.printStackTrace();
  8.             }
  9.             System.out.println(Thread.currentThread().getName()+" end: " + System.currentTimeMillis());
  10.         }
  11.     }

再次运行：

  1. Thread-A begin: 1537001008952
  2. Thread-B begin: 1537001008952
  3. Thread-A end: 1537001011953
  4. Thread-B end: 1537001014954

本实验说明：不在synchronized代码块中就是异步执行，在synchronized块中就是同步执行。

2.3 synchronized代码块间的同步性

在使用synchronized(this)代码块需要注意的是，当一个线程访问object的一个synchronized(this)同步代码块时，其它线程对同一个object中所有其他synchronized(this)同步访问被阻塞，这说明synchronized使用的“对象监视器”是一个。

和synchronized关键字修饰的方法一样，synchronize(this)代码块也是锁定的当前对象。

2.4 将任意对象作为对象监视器

多个线程调用同一个对象中得不同名称的synchronized同步方法或synchronized(this)同步代码块时，调用的效果就是按顺序执行，也就是同步的，阻塞的。

这说明synchronized同步方法或synchronized同步代码块分别有两种作用。

（1）对其他synchronized同步方法或synchronized(this)同步代码块调用呈阻塞状态。

（2）同一时间只有一个线程可以执行synchronized同步方法或synchronized(this)同步代码块中的代码。

在前面我们使用synchronized(this)格式来同步代码块，其实Java还支持对“任意对象”作为“对象监视器”来实现同步的功能。这个”任意对象“大多数是实例变量及方法的参数，使用格式为synchronized(非this对象)。

根据前面对synchronized(this)同步代码块的作用总结可知，synchronized(非this对象)格式的作用只有1种：synchronized(非this对象 X )同步代码块。

（1）在多个线程持有”对象监视器“为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this对象 X)同步代码块。

（2）当持有”对象监视器“为同一个对象的前提下，同一时间只有一个线程可以执行synchronized(非this对象X)同步代码块中的代码。

下面演示下任意对象作为对象监视器的示例：

  1. public class Test {
  2.     private String anyObject = new String();
  3.     public void service(){
  4.         synchronized (anyObject) {
  5.             System.out.println(Thread.currentThread().getName()+" begin: " + System.currentTimeMillis());
  6.             try {
  7.                 Thread.sleep(3000);
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.             System.out.println(Thread.currentThread().getName()+" end: " + System.currentTimeMillis());
  12.         }
  13.     }
  14.     public static void main(String[] args) {
  15.         Test test = new Test();
  16.         new Thread(new Runnable() {
  17.             @Override
  18.             public void run() {
  19.                 test.service();
  20.             }
  21.         },"Thread-A").start();
  22.         new Thread(new Runnable() {
  23.             @Override
  24.             public void run() {
  25.                 test.service();
  26.             }
  27.         },"Thread-B").start();
  28.     }
  29. }

运行结果：

  1. Thread-A begin: 1537008016172
  2. Thread-A end: 1537008019173
  3. Thread-B begin: 1537008019173
  4. Thread-B end: 1537008022173

锁非this对象具有一定的优点：如果在一个类中有很多个synchronized方法，这时虽然能实现同步，但会受到阻塞，所以影响运行效率；但如果使用同步代码块锁非this对象，则synchronized(非this)代码块中的程序与同步方法是异步的，不与其他锁this同步方法争抢this锁，则可大大提高运行效率。

再来看下面的示例代码：

  1. public class Test {
  2.     private String anyObject = new String();
  3.     public void service(){
  4.         synchronized (anyObject) {
  5.             System.out.println(Thread.currentThread().getName()+" begin: " + System.currentTimeMillis());
  6.             try {
  7.                 Thread.sleep(3000);
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.             System.out.println(Thread.currentThread().getName()+" end: " + System.currentTimeMillis());
  12.         }
  13.     }
  14.     synchronized public void service2(){
  15.         System.out.println(Thread.currentThread().getName()+" begin: " + System.currentTimeMillis());
  16.     }
  17.     public static void main(String[] args) {
  18.         Test test = new Test();
  19.         new Thread(new Runnable() {
  20.             @Override
  21.             public void run() {
  22.                 test.service();
  23.             }
  24.         },"Thread-A").start();
  25.         new Thread(new Runnable() {
  26.             @Override
  27.             public void run() {
  28.                 test.service2();
  29.             }
  30.         },"Thread-B").start();
  31.     }
  32. }

运行结果：

  1. Thread-A begin: 1537009027680
  2. Thread-B begin: 1537009027681
  3. Thread-A end: 1537009030680

可见，使用“synchronized(非this对象x)同步代码块”格式进行同步操作时，对象监视器必须是同一个对象，如果不是同一个对象。如果不是同一个对象监视器，运行的结果就是异步调用了，就会交叉运行。

2.5 细化三个结论

”synchronized(非this对象X)“格式的写法是将x对象本身作为“对象监视器”，这样就可以得出以下3个结论：

  1. 当多个线程同时执行synchronized(X){}同步代码块时呈同步效果。
  2. 当其他线程执行X对象中synchronized同步方法时呈同步效果。
  3. 当其他线程执行X对象方法里面的synchronized(this)代码块时也呈现同步效果。
  4. 但需要注意的是，如果其他线程调用不加synchronized关键字的方法时，还是异步调用。

2.6 静态同步synchronized方法与synchronized(class)代码块

关键字synchronized还可以在static静态方法上，如果这样写，那是对当前的*.java文件对应的Class类进行持锁。

下面测试静态同步方法：

  1. public class Test2 {
  2.     synchronized public static void service() {
  3.         System.out.println(Thread.currentThread().getName() + " begin: " + System.currentTimeMillis());
  4.         try {
  5.             Thread.sleep(3000);
  6.         } catch (InterruptedException e) {
  7.             e.printStackTrace();
  8.         }
  9.         System.out.println(Thread.currentThread().getName() + " end: " + System.currentTimeMillis());
  10.     }
  12.     public static void main(String[] args) {
  13.         new Thread(new Runnable() {
  14.             @Override
  15.             public void run() {
  16.                 Test2.service();
  17.             }
  18.         }, "Thread-A").start();
  19.         new Thread(new Runnable() {
  20.             @Override
  21.             public void run() {
  22.                 Test2.service();
  23.             }
  24.         }, "Thread-B").start();
  25.     }
  26. }

运行结果：

  1. Thread-A begin: 1537011409603
  2. Thread-A end: 1537011412608
  3. Thread-B begin: 1537011412608
  4. Thread-B end: 1537011415608

synchronized关键字加到static静态方法上是给Class类上锁，而synchronized关键字加到非static静态方法上是给对象上锁。

为了验证对象锁和Class锁不是同一个锁，来看下面的代码：

  1. public class Test2 {
  2.     synchronized public static void service() {
  3.         System.out.println(Thread.currentThread().getName() + " begin: " + System.currentTimeMillis());
  4.         try {
  5.             Thread.sleep(3000);
  6.         } catch (InterruptedException e) {
  7.             e.printStackTrace();
  8.         }
  9.         System.out.println(Thread.currentThread().getName() + " end: " + System.currentTimeMillis());
  10.     }
  11.     synchronized public void service2(){
  12.         System.out.println(Thread.currentThread().getName() + " begin: " + System.currentTimeMillis());
  13.         try {
  14.             Thread.sleep(3000);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.         System.out.println(Thread.currentThread().getName() + " end: " + System.currentTimeMillis());
  19.     }
  20.     public static void main(String[] args) {
  21.         new Thread(new Runnable() {
  22.             @Override
  23.             public void run() {
  24.                 Test2.service();
  25.             }
  26.         }, "Thread-A").start();
  27.         new Thread(new Runnable() {
  28.             @Override
  29.             public void run() {
  30.                 new Test2().service2();
  31.             }
  32.         }, "Thread-B").start();
  33.     }
  34. }

运行结果：

  1. Thread-A begin: 1537012019151
  2. Thread-B begin: 1537012019152
  3. Thread-A end: 1537012022152
  4. Thread-B end: 1537012022152

异步的原因是持有不同的锁，一个是对象锁，另外一个是Class锁，Class锁可以对所有类的实例对象起作用。

下面我们测试synchronized(class)代码块，示例代码如下：

  1. public class Test {
  2.     public void service(){
  3.         synchronized (Test.class) {
  4.             System.out.println(Thread.currentThread().getName()+" begin: " + System.currentTimeMillis());
  5.             try {
  6.                 Thread.sleep(3000);
  7.             } catch (InterruptedException e) {
  8.                 e.printStackTrace();
  9.             }
  10.             System.out.println(Thread.currentThread().getName()+" end: " + System.currentTimeMillis());
  11.         }
  12.     }
  13.     public static void main(String[] args) {
  14.         new Thread(new Runnable() {
  15.             @Override
  16.             public void run() {
  17.                 new Test().service();
  18.             }
  19.         },"Thread-A").start();
  20.         new Thread(new Runnable() {
  21.             @Override
  22.             public void run() {
  23.                 new Test().service();
  24.             }
  25.         },"Thread-B").start();
  26.     }
  27. }

运行结果：

  1. Thread-A begin: 1537011197190
  2. Thread-A end: 1537011200191
  3. Thread-B begin: 1537011200191
  4. Thread-B end: 1537011203191

同步synchronized(class)代码块的作用其实和synchronized static方法的作用一样。

2.7 数据类型String的常量池特性

在JVM中具有String常量池缓存的功能，将synchronized(String)同步块与String联合使用时，要注意常量池以带来的一些例外。

  1. public class Test {
  2.     public void service(String str){
  3.         synchronized (str) {
  4.             while (true) {
  5.                 System.out.println(Thread.currentThread().getName() + " time: " + System.currentTimeMillis());
  6.             }
  7.         }
  8.     }
  9.     public static void main(String[] args) {
  10.         new Thread(new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 new Test().service("AA");
  14.             }
  15.         },"Thread-A").start();
  16.         new Thread(new Runnable() {
  17.             @Override
  18.             public void run() {
  19.                 new Test().service("AA");
  20.             }
  21.         },"Thread-B").start();
  22.     }
  23. }

运行结果：

  1. Thread-A time: 1537013470535
  2. Thread-A time: 1537013470535
  3. Thread-A time: 1537013470535
  4. ...

运行结果显示A线程陷入了死循环，而B线程一直在等待未执行。出现这样的结果就是两个持有相同的锁，所以造成B线程不能执行。这就是String常量池带来的问题。因此在大多数情况下，同步synchronized代码块都不使用String作为锁对象，而改用其他，比如new Object()实例化一个Object对象，但它并不放入缓存中。

改造后的代码：

  1. public class Test {
  2.     public void service(Object str){
  3.         synchronized (str) {
  4.             while (true) {
  5.                 System.out.println(Thread.currentThread().getName() + " time: " + System.currentTimeMillis());
  6.             }
  7.         }
  8.     }
  9.     public static void main(String[] args) {
  10.         new Thread(new Runnable() {
  11.             @Override
  12.             public void run() {
  13.                 new Test().service(new Object());
  14.             }
  15.         },"Thread-A").start();
  16.         new Thread(new Runnable() {
  17.             @Override
  18.             public void run() {
  19.                 new Test().service(new Object());
  20.             }
  21.         },"Thread-B").start();
  22.     }
  23. }

运行结果：

  1. Thread-A time: 1537015931981
  2. Thread-A time: 1537015931982
  3. Thread-B time: 1537015931982
  4. Thread-B time: 1537015931982
  5. ...

交替打印的原因是持有的锁不是一个。

2.8 同步synchronized方法无限等待与解决

同步方法极易造成死循环。示例代码：

  1. public class Test {
  2.     synchronized public void serviceA() {
  3.         System.out.println(Thread.currentThread().getName() + " begin: " + System.currentTimeMillis());
  4.         boolean is = true;
  5.         while (is){
  7.         }
  8.         System.out.println(Thread.currentThread().getName() + " end: " + System.currentTimeMillis());
  9.     }
  11.     synchronized public void serviceB() {
  12.         System.out.println(Thread.currentThread().getName() + " begin: " + System.currentTimeMillis());
  13.         System.out.println(Thread.currentThread().getName() + " end: " + System.currentTimeMillis());
  14.     }
  16.     public static void main(String[] args) {
  17.         Test test = new Test();
  18.         new Thread(new Runnable() {
  19.             @Override
  20.             public void run() {
  21.                 test.serviceA();
  22.             }
  23.         }, "Thread-A").start();
  24.         new Thread(new Runnable() {
  25.             @Override
  26.             public void run() {
  27.                 test.serviceB();
  28.             }
  29.         }, "Thread-B").start();
  30.     }
  31. }

线程B永远得不到运行的机会，锁死了。

解决的方法就是使用同步块。更改后的代码如下：

  1. public class Test {
  2.     private Object objectA = new Object();
  3.     public void serviceA() {
  4.         synchronized (objectA) {
  5.             System.out.println(Thread.currentThread().getName() + " begin: " + System.currentTimeMillis());
  6.             boolean is = true;
  7.             while (is) {
  9.             }
  10.             System.out.println(Thread.currentThread().getName() + " end: " + System.currentTimeMillis());
  11.         }
  12.     }
  14.     private Object objectB = new Object();
  15.     synchronized public void serviceB() {
  16.         synchronized (objectB) {
  17.             System.out.println(Thread.currentThread().getName() + " begin: " + System.currentTimeMillis());
  18.             System.out.println(Thread.currentThread().getName() + " end: " + System.currentTimeMillis());
  19.         }
  20.     }
  21.     ....
  22. }

2.9 多线程的死锁

Java多线程死锁是一个经典问题，因为不同的线程都在等待根本不可能被释放的锁，从而导致所有的任务都无法完成。在多线程技术中，“死锁”是必须避免的，因为这会造成线程的“假死”。

  1. public class DealThread implements Runnable {
  2.     public String username;
  3.     public Object locak1 = new Object();
  4.     public Object locak2 = new Object();
  5.     public void setFlag(String username){
  6.         this.username = username;
  7.     }
  9.     @Override
  10.     public void run() {
  11.         if (username.equals("a")){
  12.             synchronized (locak1){
  13.                 System.out.println("username:"+username);
  14.                 try {
  15.                     Thread.sleep(3000);
  16.                 } catch (InterruptedException e) {
  17.                     e.printStackTrace();
  18.                 }
  19.                 synchronized (locak2){
  20.                     System.out.println("按lock1-》lock2执行");
  21.                 }
  22.             }
  23.         }
  25.         if (username.equals("b")){
  26.             synchronized (locak2){
  27.                 System.out.println("username:"+username);
  28.                 try {
  29.                     Thread.sleep(3000);
  30.                 } catch (InterruptedException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.                 synchronized (locak1){
  34.                     System.out.println("按lock2-》lock1执行");
  35.                 }
  36.             }
  37.         }
  38.     }
  40.     public static void main(String[] args) throws InterruptedException {
  41.         DealThread dealThread = new DealThread();
  42.         dealThread.setFlag("a");
  43.         Thread threadA = new Thread(dealThread);
  44.         threadA.start();
  45.         Thread.sleep(100);
  46.         dealThread.setFlag("b");
  47.         Thread threadB = new Thread(dealThread);
  48.         threadB.start();
  49.     }
  50. }

运行结果，出现死锁：

  1. username:a
  2. username:b

死锁是程序设计的Bug，在设计程序时就需要避免双方互相持有对方的锁的情况。需要说明的是，本实验使用synchronized嵌套的代码结构来实现死锁，其实不使用嵌套的代码结构也会出现死锁，与嵌套不嵌套无任何关系，不要被代码结构所误导。只要互相等待对方释放锁就有可能出现死锁。

可以使用JDK自带的工具来检测是否有死锁的现象。首先进入CMD命令行界面，再进入JDK的安装文件夹中的

bin目录，执行jps命令。得到运行的线程Run的id值。再执行jstack命令，查看结果。

完整命令演示如下：

  1. D:\Java\jdk1.8.0\bin>jps
  2. 8240 Launcher
  3. 13252 Jps
  4. 12312
  5. 7948 DealThread
  6. D:\Java\jdk1.8.0\bin>jstack -l 7948
  7. ....
  9. Java stack information for the threads listed above:
  10. ===================================================
  11. "Thread-1":
  12.         at cn.zyzpp.thread2_3.DealThread.run(DealThread.java:39)
  13.         - waiting to lock <0x00000000d6089e80> (a java.lang.Object)
  14.         - locked <0x00000000d6089e90> (a java.lang.Object)
  15.         at java.lang.Thread.run(Thread.java:745)
  16. "Thread-0":
  17.         at cn.zyzpp.thread2_3.DealThread.run(DealThread.java:25)
  18.         - waiting to lock <0x00000000d6089e90> (a java.lang.Object)
  19.         - locked <0x00000000d6089e80> (a java.lang.Object)
  20.         at java.lang.Thread.run(Thread.java:745)
  22. Found 1 deadlock.

2.10 锁对象的改变

在任何数据类型作为同步锁时，需要注意的是，是否有多个线程同时持有锁对象，如果同时持有锁对象，则这些线程之间就是同步的；如果分别获得锁对象，这些线程之间就是异步的。

  1. public class Test {
  2.     private String lock = "123";
  3.     public void service(){
  4.         synchronized (lock) {
  5.             System.out.println(Thread.currentThread().getName()+" begin: " + System.currentTimeMillis());
  6.             lock = "456";
  7.             try {
  8.                 Thread.sleep(2000);
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  12.             System.out.println(Thread.currentThread().getName()+" end: " + System.currentTimeMillis());
  13.         }
  14.     }
  15.     public static void main(String[] args) throws InterruptedException {
  16.         Test test = new Test();
  17.         new Thread(new Runnable() {
  18.             @Override
  19.             public void run() {
  20.                 test.service();
  21.             }
  22.         },"Thread-A").start();
  23.         Thread.sleep(50);
  24.         new Thread(new Runnable() {
  25.             @Override
  26.             public void run() {
  27.                 test.service();
  28.             }
  29.         },"Thread-B").start();
  30.     }
  31. }

运行结果：

  1. Thread-A begin: 1537019992452
  2. Thread-B begin: 1537019992652
  3. Thread-A end: 1537019994453
  4. Thread-B end: 1537019994653

为什么是乱序？因为50ms过后线程取得的锁时“456”。

把lock = "456"放在Thread.sleep(2000)之后，再次运行。

  1. Thread-A begin: 1537020101553
  2. Thread-A end: 1537020103554
  3. Thread-B begin: 1537020103554
  4. Thread-B end: 1537020105558

线程A和线程B持有的锁都是“123”，虽然将锁改成了“456”，但结果还是同步的，因为A和B争抢的锁是“123”。

还需要提示一下，只要对象不变，即使对象的属性被改变，运行的结果还是同步的。

3.volatile关键字

关键字volatile的主要作用是使变量在多个线程间可见。

3.1 关键字volatile与死循环

如果不是在多继承的情况下，使用继承Thread类和实现Runnable接口在取得程序运行的结果上并没有多大的区别。如果一旦出现”多继承“的情况，则用实现Runable接口的方式来处理多线程的问题就是很有必要的。

  1. public class PrintString implements Runnable{
  2.     private boolean isContinuePrint = true;
  4.     @Override
  5.     public void run() {
  6.         while (isContinuePrint){
  7.             System.out.println("Thread: "+Thread.currentThread().getName());
  8.             try {
  9.                 Thread.sleep(1000);
  10.             } catch (InterruptedException e) {
  11.                 e.printStackTrace();
  12.             }
  13.         }
  14.     }
  16.     public boolean isContinuePrint() {
  17.         return isContinuePrint;
  18.     }
  20.     public void setContinuePrint(boolean continuePrint) {
  21.         isContinuePrint = continuePrint;
  22.     }
  24.     public static void main(String[] args) throws InterruptedException {
  25.         PrintString printString = new PrintString();
  26.         Thread thread = new Thread(printString,"Thread-A");
  27.         thread.start();
  28.         Thread.sleep(100);
  29.         System.out.println("我要停止它！" + Thread.currentThread().getName());
  30.         printString.setContinuePrint(false);
  31.     }
  32. }

运行结果：

  1. Thread: Thread-A
  2. 我要停止它！main

上面的代码运行起来没毛病，但是一旦运行在 -server服务器模式中64bit的JVM上时，会出现死循环。解决的办法是使用volatile关键字。

关键字volatile的作用是强制从公共堆栈中取得变量的值，而不是从线程私有数据栈中取得变量的值。

3.2 解决异步死循环

在研究volatile关键字之前先来做一个测试用例，代码如下：

  1. public class PrintString implements Runnable{
  2.     private boolean isRunnning = true;
  4.     @Override
  5.     public void run() {
  6.         System.out.println("Thread begin: "+Thread.currentThread().getName());
  7.         while (isRunnning == true){
  8.         }
  9.         System.out.println("Thread end: "+Thread.currentThread().getName());
  10.     }
  12.     public boolean isRunnning() {
  13.         return isRunnning;
  14.     }
  16.     public void setRunnning(boolean runnning) {
  17.         isRunnning = runnning;
  18.     }
  20.     public static void main(String[] args) throws InterruptedException {
  21.         PrintString printString = new PrintString();
  22.         Thread thread = new Thread(printString,"Thread-A");
  23.         thread.start();
  24.         Thread.sleep(1000);
  25.         printString.setRunnning(false);
  26.         System.out.println("我要停止它！" + Thread.currentThread().getName());
  27.     }
  29. }

JVM有Client和Server两种模式，我们可以通过运行：java -version来查看jvm默认工作在什么模式。我们在IDE中把JVM设置为在Server服务器的环境中，具体操作只需配置运行参数为 -server。然后启动程序，打印结果：

  1. Thread begin: Thread-A
  2. 我要停止它！main

代码 System.out.println("Thread end: "+Thread.currentThread().getName());从未被执行。

是什么样的原因造成将JVM设置为-server就出现死循环呢？

在启动thread线程时，变量boolean isContinuePrint = true;存在于公共堆栈及线程的私有堆栈中。在JVM设置为-server模式时为了线程运行的效率，线程一直在私有堆栈中取得isRunning的值是true。而代码thread.setRunning(false);虽然被执行，更新的却是公共堆栈中的isRunning变量值false，所以一直就是死循环的状态。内存结构图：

这个问题其实就是私有堆栈中的值和公共堆栈中的值不同步造成的。解决这样的问题就要使用volatile关键字了，它主要的作用就是当线程访问isRunning这个变量时，强制性从公共堆栈中进行取值。

将代码更改如下：

  1. volatile private boolean isRunnning = true;

再次运行：

  1. Thread begin: Thread-A
  2. 我要停止它！main
  3. Thread end: Thread-A

通过使用volatile关键字，强制的从公共内存中读取变量的值，内存结构如图所示：

使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字最致命的缺点是不支持原子性。

下面将关键字synchronized和volatile进行一下比较：

  1. 关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修饰方法，以及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。
  2. 多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
  3. volatile能保证数据的可见性，但不能保证原子性；而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。
  4. 再次重申一下，关键字volatile解决的是变量在多个线程之间的可见性；而synchronized关键字解决的是多个线程之间访问资源的同步性。

线程安全包含原子性和可见性两个方面，Java的同步机制都是围绕这两个方面来确保线程安全的。

3.3 volatile非原子性的特征

关键字虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，那么也就不具备原子性。

示例代码：

  1. public class MyThread extends Thread {
  2.     volatile private static int count;
  3.     @Override
  4.     public void run() {
  5.         addCount();
  6.     }
  8.     private void addCount() {
  9.         for (int i = 0;i<100;i++){
  10.             count++;
  11.         }
  12.         System.out.println(count);
  13.     }
  15.     public static void main(String[] args) {
  16.         MyThread[] myThreads = new MyThread[100];
  17.         for (int i=0;i<100;i++){
  18.             myThreads[i] = new MyThread();
  19.         }
  20.         for (int i=0;i<100;i++){
  21.             myThreads[i].start();
  22.         }
  23.     }
  24. }

运行结果：

  1. ...
  2. 8253
  3. 8353
  4. 8153
  5. 8053
  6. 7875
  7. 7675

在addCount方法上加入synchronized同步关键字与static关键字，达到同步的效果。

再次运行结果：

  1. ....
  2. 9600
  3. 9700
  4. 9800
  5. 9900
  6. 10000

关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是：如果修改实例变量中的数据，比如i++，也就是比

i=i+1，则这样的操作其实并不是一个原子操作，也就是非线程安全。表达式i++的操作步骤分解为下面三步：

  1. 从内存中取i的值；
  2. 计算i的值；
  3. 将i值写入到内存中。

假如在第二步计算i值的时候，另外一个线程也修改i的值，那么这个时候就会脏数据。解决的方法其实就是使用synchronized关键字。所以说volatile关键字本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存中。

3.4 使用原子类进行i++操作

除了在i++操作时使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类进行实现。

原子操作是不可分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。它可以在没有锁的情况下做到线程安全。

示例代码：

  1. public class MyThread extends Thread {
  2.     private static AtomicInteger count = new AtomicInteger(0);
  3.     @Override
  4.     public void run() {
  5.         addCount();
  6.     }
  8.     private static void addCount() {
  9.         for (int i = 0;i<100;i++){
  10.             System.out.println(count.incrementAndGet());
  11.         }
  12.     }
  14.     public static void main(String[] args) {
  15.         MyThread[] myThreads = new MyThread[100];
  16.         for (int i=0;i<100;i++){
  17.             myThreads[i] = new MyThread();
  18.         }
  19.         for (int i=0;i<100;i++){
  20.             myThreads[i].start();
  21.         }
  22.     }
  23. }

打印结果：

  1. ....
  2. 9996
  3. 9997
  4. 9998
  5. 9999
  6. 10000

成功达到累加的效果。

3.5 原子类也不安全

原子类在具有有逻辑性的情况下输出结果也具有随机性。

示例代码：

  1. public class MyThread extends Thread {
  2.     private static AtomicInteger count = new AtomicInteger(0);
  4.     public MyThread(String name) {
  5.         super(name);
  6.     }
  8.     @Override
  9.     public void run() {
  10.         this.addCount();
  11.     }
  13.     private void addCount() {
  14.         System.out.println(Thread.currentThread().getName()+"加100之后："+count.addAndGet(100));
  15.         count.addAndGet(1);
  16.     }
  18.     public static void main(String[] args) throws InterruptedException {
  19.         MyThread[] myThreads = new MyThread[10];
  20.         for (int i = 0; i < 10; i++) {
  21.             myThreads[i] = new MyThread("Thread-"+i);
  22.         }
  23.         for (int i = 0; i < 10; i++) {
  24.             myThreads[i].start();
  25.         }
  26.         Thread.sleep(2000);
  27.         System.out.println(MyThread.count);
  28.     }
  29. }

打印结果：

  1. Thread-0加100之后：100
  2. Thread-2加100之后：201
  3. Thread-1加100之后：302
  4. Thread-5加100之后：602
  5. Thread-4加100之后：502
  6. Thread-3加100之后：402
  7. Thread-6加100之后：706
  8. Thread-7加100之后：807
  9. Thread-9加100之后：908
  10. Thread-8加100之后：1009
  11. 1010

可以看到，结果值正确但是打印顺序出错了，出现这样的原因是因为AtomicInteger的addAndGet()方法是原子的，但方法与方法之间的调用却不是原子的。也就是方法addCount的调用不是原子的。解决这样的问题必须要用同步。

3.6 synchronized代码块有volatile同步的功能

关键字synchronized可以使多个线程访问同一个资源具有同步性，而且它还具有将线程工作内存中的私有变量与公共内存中的变量同步的功能。

我们把前面讲到的异步死循环代码改造一下：

  1. public class PrintString implements Runnable{
  2.     private boolean isRunnning = true;
  4.     @Override
  5.     public void run() {
  6.         String lock = new String();
  7.         System.out.println("Thread begin: "+Thread.currentThread().getName());
  8.         while (isRunnning == true){
  9.             synchronized (lock){
  10.                 //加与不加的效果就是是否死循环
  11.             }
  12.         }
  13.         System.out.println("Thread end: "+Thread.currentThread().getName());
  14.     }
  16.     public boolean isRunnning() {
  17.         return isRunnning;
  18.     }
  20.     public void setRunnning(boolean runnning) {
  21.         isRunnning = runnning;
  22.     }
  24.     public static void main(String[] args) throws InterruptedException {
  25.         PrintString printString = new PrintString();
  26.         Thread thread = new Thread(printString,"Thread-A");
  27.         thread.start();
  28.         Thread.sleep(1000);
  29.         printString.setRunnning(false);
  30.         System.out.println("我要停止它！" + Thread.currentThread().getName());
  31.     }
  33. }

打印结果：

  1. Thread begin: Thread-A
  2. 我要停止它！main
  3. Thread end: Thread-A

关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或某一个代码块。它包含两个特征：互斥相和可见性。同步synchronized不仅可以解决一个线程看到对象处于不一致的状态，还可以保证进入同步方法或者同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。

学习多线程并发。要着重“外修互斥，内修可见”，这是掌握多线程、学习多线程并发的重要技术点。

参考

《Java多线程编程核心技术》高洪岩著

扩展

扩展

Java多线程编程核心技术(一)Java多线程技能

Java多线程编程核心技术(三)多线程通信

Java多线程核心技术(四)Lock的使用

Java多线程核心技术(五)单例模式与多线程

Java多线程核心技术(六)线程组与线程异常

Java多线程编程核心技术(二)对象及变量的并发访问的更多相关文章

  1. Java多线程编程核心技术(三)多线程通信

    线程是操作系统中独立的个体,但这些个体如果不经过特殊的处理就不能成为一个整体.线程间的通信就是成为整体的必用方案之一,可以说,使线程间进行通信后,系统之间的交互性会更强大,在大大提高CPU利用率的同时 ...

  2. Java多线程编程核心技术(一)Java多线程技能

    1.进程和线程 一个程序就是一个进程,而一个程序中的多个任务则被称为线程. 进程是表示资源分配的基本单位,线程是进程中执行运算的最小单位,亦是调度运行的基本单位. 举个例子: 打开你的计算机上的任务管 ...

  3. Java多线程编程核心技术---对象及变量的并发访问（二）

    数据类型String的常量池特性 在JVM中具有String常量池缓存的功能. public class Service { public static void print(String str){ ...

  4. Java多线程编程核心技术-第2章-对象及变量的并发访问-读书笔记

    第 2 章 对象及变量的并发访问 本章主要内容 synchronized 对象监视器为 Object 时的使用. synchronized 对象监视器为 Class 时的使用. 非线程安全是如何出现的 ...

  5. Java多线程编程核心技术---学习分享

    继承Thread类实现多线程 public class MyThread extends Thread { @Override public void run() { super.run(); Sys ...

  6. Java多线程编程核心技术

    Java多线程编程核心技术 这本书有利于对Java多线程API的理解,但不容易从中总结规律. JDK文档 1. Thread类 部分源码: public class Thread implements ...

  7. 《Java 多线程编程核心技术》- 笔记

    作为业务开发人员,能够在工作中用到的技术其实不多.虽然平时老是说什么,多线程,并发,注入,攻击!但是在实际工作中,这些东西不见得用得上.因为,我们用的框架已经把这些事做掉了. 比如web开发,外面有大 ...

  8. 《java多线程编程核心技术》不使用等待通知机制 实现线程间通信的 疑问分析

    不使用等待通知机制 实现线程间通信的 疑问分析 2018年04月03日 17:15:08       ayf 阅读数:33 编辑 <java多线程编程核心技术>一书第三章开头,有如下案例: ...

  9. 《Java多线程编程核心技术》知识梳理

    <Java多线程编程核心技术> @author ergwang https://www.cnblogs.com/ergwang/ 文章末尾附pdf和png下载链接 第1章 Java多线程技 ...

随机推荐

  1. 使用adb命令通过IP地址连接手机

    前提:已经通过USB设备线连接过电脑,并成功安装驱动. adb连接手机进行调试有两种方式,一种是使用USB线,另一种是使用无线WiFi. 第一种  使用USB线连接 1. 在手机上启用USB调试 2. ...

  2. matlab练习程序（波纹扭曲）

    其实就是用sin或cos对x,y坐标进行变换,处理的时候依然是反向变换. 类似的,用不同的函数能得到不同的扭曲效果,比如log,1/x,exp等等. 效果如下: 代码如下(还给出了如何生成gif图片的 ...

  3. ELk(Elasticsearch, Logstash, Kibana)的安装配置

    目录 ELk(Elasticsearch, Logstash, Kibana)的安装配置 1. Elasticsearch的安装-官网 2. Kibana的安装配置-官网 3. Logstash的安装 ...

  4. [katalon] 页面切换

    UI自动化测试过程中会涉及到需要切换多个页面, 如点击一个按钮之后跳转到新的页面, 后者A站点提交信息后,B站点审核. Katalon虽然不支持控制多个浏览器,但是支持处理tab切换. 核心方法是使用 ...

  5. [20190324]奇怪的GV$FILESPACE_USAGE视图.txt

    [20190324]奇怪的GV$FILESPACE_USAGE视图.txt--//发现GV$FILESPACE_USAGE定义很奇怪,做一个记录.1.环境:SCOTT@book> @ ver1P ...

  6. cmd输出控制台传递的参数

    public class Test2{ public static void main(String[] args){ System.out.println(args[0]); System.out. ...

  7. 爬取mzi.com妹子图片网站（requests库）

    看了崔大佬的文章,写了这个爬虫,学习了!原文地址 现在该网站加了反爬机制,不过在headers里加上refere参数就行了. 以下代码仅做学习记录之用: from bs4 import Beautif ...

  8. mysql 数据库 命令行的操作——对表和字段的操作

    一.对表的操作 1.查看所有表 show tables: 2.创建表 create table 表名(字段1 类型1 约束1 ,字段2 类型2 约束2): 3.修改表的名字 rename table ...

  9. SQLServer数据库增删改查

    一.数据库定义 数据库(Database)是按照数据结构来组织.存储和管理数据的仓库.数据库的操作分为两种形式:一种是直接在数据库管理工具图形化界面进行操作:一种是使用数据库脚本进行操作,数据库脚本可 ...

  10. 超简单的gif图制作工具

    测试成功了: 软件灵者Gif录制1.0 使用方法注意: 扩展: 安卓端想要制作gif可参考此方法(还没测试):https://blog.csdn.net/u012604745/article/deta ...