synchronized 这个关键字，我相信对于并发编程有一定了解的人，一定会特别熟悉，对于一些可能在多线程环境下可能会有并发问题的代码，或者方法，直接加上synchronized，问题就搞定了。
但是用归用，你明白它为什么要这么用？为什么就能解决我们所说的线程安全问题？
下面，可乐将和大家一起深入的探讨这个关键字用法。
1、示例代码结果？
首先大家看一段代码，大家想想最后的打印count结果是多少？
代码语言：javascript复制 1 package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;
2
3
4 /**
5 * Create by ItCoke
6 */
7 public class SynchronizedTest implements Runnable{
8
9 public static int count = 0;
10
11 @Override
12 public void run() {
13 addCount();
14
15 }
16
17 public void addCount(){
18 int i = 0;
19 while (i < 100000) {
20 count ;
21 }
22 }
23
24 public static void main(String[] args) throws Exception{
25 SynchronizedTest obj = new SynchronizedTest();
26 Thread t1 = new Thread(obj);
27 Thread t2 = new Thread(obj);
28 t1.start();
29 t2.start();
30 t1.join();
31 t2.join();
32 System.out.println(count);
33
34 }
35
36
37 }代码很简单，主线程中启动两个线程t1和t2，分别调用 addCount() 方法，将count的值都加100000，然后调用 join() 方法，表示主线程等待这两个线程执行完毕。最后打印 count 的值。
应该没有答案一定是 200000 的同学吧，很好，大家都具备一定的并发知识。
这题的答案是一定小于等于 200000，至于原因也很好分析，比如 t1线程获取count的值为0，然后执行了加1操作，但是还没来得及同步到主内存，这时候t2线程去获取主内存的count值，发现还是0，然后继续自己的加1操作。也就是t1和t2都执行了加1操作，但是最后count的值依然是1。
那么我们应该如何保证结果一定是 200000呢？答案就是用 synchronized。
2、修饰代码块
直接上代码：
代码语言：javascript复制 1 package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;
2
3
4 /**
5 * Create by ItCoke
6 */
7 public class SynchronizedTest implements Runnable{
8
9 public static int count = 0;
10
11 private Object objMonitor = new Object();
12
13 @Override
14 public void run() {
15 addCount();
16
17 }
18
19 public void addCount(){
20 synchronized (objMonitor){
21 int i = 0;
22 while (i < 100000) {
23 count ;
24 }
25 }
26
27 }
28
29 public static void main(String[] args) throws Exception{
30 SynchronizedTest obj = new SynchronizedTest();
31 Thread t1 = new Thread(obj);
32 Thread t2 = new Thread(obj);
33 t1.start();
34 t2.start();
35 t1.join();
36 t2.join();
37 System.out.println(count);
38
39 }
40
41
42 }我们在 addCount 方法体中增加了一个 synchronized 代码块，将里面的 while 循环包括在其中，保证同一时刻只能有一个线程进入这个循环去改变count的值。
3、修饰普通方法
代码语言：javascript复制 1 package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;
2
3
4 /**
5 * Create by ItCoke
6 */
7 public class SynchronizedTest implements Runnable{
8
9 public static int count = 0;
10
11 private Object objMonitor = new Object();
12
13 @Override
14 public void run() {
15 addCount();
16
17 }
18
19 public synchronized void addCount(){
20 int i = 0;
21 while (i < 100000) {
22 count ;
23 }
24
25 }
26
27 public static void main(String[] args) throws Exception{
28 SynchronizedTest obj = new SynchronizedTest();
29 Thread t1 = new Thread(obj);
30 Thread t2 = new Thread(obj);
31 t1.start();
32 t2.start();
33 t1.join();
34 t2.join();
35 System.out.println(count);
36
37 }
38
39
40 }对比上面修饰代码块，直接将 synchronized 加到 addCount 方法中，也能解决线程安全问题。
4、修饰静态方法
这个我们就不贴代码演示了，将 addCount() 声明为一个 static 修饰的方法，然后在加上 synchronized ，也能解决线程安全问题。
5、原子性、可见性、有序性
通过 synchronized 修饰的方法或代码块，能够同时保证这段代码的原子性、可见性和有序性，进而能够保证这段代码的线程安全。
比如通过 synchronized 修饰的代码块：
其中 objMonitor 表示锁对象（下文会介绍这个锁对象），只有获取到这个锁对象之后，才能执行里面的代码，执行完毕之后，在释放这个锁对象。那么同一时刻就会只有一个线程去执行这段代码，把多线程变成了单线程，当然不会存在并发问题了。
这个过程，大家可以想象在公司排队上厕所的情景。
对于原子性，由于同一时刻单线程操作，肯定能够保证原子性。
对于有序性，在JMM内存模型中的Happens-Before规定如下，所以也是能够保证有序性的。
代码语言：javascript复制程序的顺序性规则（Program Order Rule）：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作。最后对于可见性，JMM内存模型也规定了：
代码语言：javascript复制对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store、write操作）。大家可能会奇怪，synchronized 并没有lock和unlock操作啊，怎么也能够保证可见性，大家不要急，其实JVM对于这个关键字已经隐式的实现了，下文看字节码会明白的。
6、锁对象
大家要注意，我在通过synchronized修饰同步代码块时，使用了一个 Object 对象，名字叫 objMonitor。而对于修饰普通方法和静态方法时，只是在方法声明时说明了，并没有锁住什么对象，其实这三者都有各自的锁对象，只有获取了锁对象，线程才能进入执行里面的代码。
代码语言：javascript复制1、修饰代码块：锁定锁的是synchonized括号里配置的对象
2、修饰普通方法：锁定调用当前方法的this对象
3、修饰静态方法：锁定当前类的Class对象多个线程之间，如果要通过 synchronized 保证线程安全，获取的要是同一把锁。如果多个线程多把锁，那么就会有线程安全问题。如下：
代码语言：javascript复制 1 package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;
2
3
4 /**
5 * Create by ItCoke
6 */
7 public class SynchronizedTest implements Runnable{
8
9 public static int count = 0;
10
11
12
13 @Override
14 public void run() {
15 addCount();
16
17 }
18
19 public void addCount(){
20 Object objMonitor = new Object();
21 synchronized(objMonitor){
22 int i = 0;
23 while (i < 100000) {
24 count ;
25 }
26 }
27 }
28
29 public static void main(String[] args) throws Exception{
30 SynchronizedTest obj = new SynchronizedTest();
31 Thread t1 = new Thread(obj);
32 Thread t2 = new Thread(obj);
33 t1.start();
34 t2.start();
35 t1.join();
36 t2.join();
37 System.out.println(count);
38
39 }
40
41
42 }我们把原来的锁 objMonitor 对象从全局变量移到 addCount() 方法中，那么每个线程进入每次进入addCount() 方法都会新建一个 objMonitor 对象，也就是多个线程用多把锁，肯定会有线程安全问题。
7、可重入
可重入什么意思？字面意思就是一个线程获取到这个锁了，在未释放这把锁之前，还能进入获取锁，如下：
在 addCount() 方法的 synchronized 代码块中继续调用 printCount() 方法，里面也有一个 synchronized ，而且都是获取的同一把锁——objMonitor。
synchronized 是能够保证这段代码正确运行的。至于为什么具有这个特性，可以看下文的实现原理。
8、实现原理
对于如下这段代码：
代码语言：javascript复制 1 package com.ys.algorithmproject.leetcode.demo.concurrency.synchronizedtest;
2
3 /**
4 * Create by YSOcean
5 */
6 public class SynchronizedByteClass {
7 Object objMonitor = new Object();
8
9 public synchronized void method1(){
10 System.out.println("Hello synchronized 1");
11 }
12
13 public synchronized static void method2(){
14 System.out.println("Hello synchronized 2");
15 }
16
17 public void method3(){
18 synchronized(objMonitor){
19 System.out.println("Hello synchronized 2");
20 }
21
22 }
23
24 public static void main(String[] args) {
25
26 }
27 }我们可以通过两种方法查看其class文件的汇编代码。
①、IDEA下载 jclasslib 插件
然后点击 View——Show Bytecode With jclasslib
②、通过 javap 命令
代码语言：javascript复制javap -v 文件名（不要后缀）注意：这里生成汇编的命令是根据编译之后的字节码文件（class文件），所以要先编译。
③、修饰代码块汇编代码
我们直接看method3() 的汇编代码：
对于上图出现的 monitorenter 和 monitorexit 指令，我们查看 JVM虚拟机规范：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html，可以看到对这两个指令的介绍。
下面我们说明一下这两个指令：
一、monitorenter
每个对象与一个监视器锁（monitor）关联。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：
1、如果 monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。
2、如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.
3.如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。
二、monitorexit
执行monitorexit的线程必须是object ref所对应的monitor的所有者。
指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。
通过上面介绍，我们可以知道 synchronized 底层就是通过这两个命令来执行的同步机制，由此我们也可以看出synchronized 具有可重入性。
③、修饰普通方法和静态方法汇编代码
可以看到都是通过指令 ACC_SYNCHRONIZED 来控制的，虽然没有看到方法的同步并没有通过指令monitorenter和monitorexit来完成，但其本质也是通过这两条指令来实现。
当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。 其实和修饰代码块本质上没有区别，只是方法的同步是一种隐式的方式来实现。
9、异常自动unlock
可能会有细心的朋友发现，我在介绍 synchronized 修饰代码块时，给出的汇编代码，用红框圈住了两个 monitorexit，根据我们前面介绍，获取monitor加1，退出monitor减1，等于0时，就没有锁了。那为啥会有两个 monitorexit，而只有一个 monitorenter 呢？
第 6 行执行 monitorenter，然后第16行执行monitorexit，然后执行第17行指令 goto 25，表示跳到第25行代码，第25行是 return，也就是直接结束了。
那第20-24行代码中是什么意思呢？其中第 24 行指令 athrow 表示Java虚拟机隐式处理方法完成异常结束时的监视器退出，也就是执行发生异常了，然后去执行 monitorexit。
进而可以得到结论：
代码语言：javascript复制synchronized 修饰的方法或代码块，在执行过程中抛出异常了，也能释放锁（unlock）我们可以看如下方法，手动抛出异常：
然后获取其汇编代码，就只有一个 monitorexit 指令了。
