Synchronized

2020-03-01

Synchronized 简介

同步方法（Synchronized）支持一种简单的策略来防止线程干扰、内存一致性错误：如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都是通过同步方法完成的。
能够保证在同一时刻最多只有一个线程执行同步方法中的代码，以达到保证并发安全的效果。
被 Synchronized 修饰的方法具备原子性
JVM会自动通过 monitor 来加锁和解锁，保证了同一时刻只有一个线程可以执行指定代码，从而保证了线程安全，同时具有可重入和不可中断的性质。

Synchronized 是 Java 的关键字，被 Java 语言原生支持。
是最基本的互斥同步手段
是并发编程中的元老级角色

不使用并发控制的安全隐患

示例：两个线程同时 i++ ，最后结果会比预计的少。

# i++ 原理解析
1. 读取 i		
2. i = i +1
3. 将 i 的值写入内存中

package com.xdclass.couponapp.test.SynchronizedDemo;

/**
 * 消失的请求数
 * 控制台输出：144313     理想结果应该是 200000
 */
public class DisappearRequest1 implements Runnable{
    static DisappearRequest1 instance = new DisappearRequest1();

    static int i = 0;

    /**
     * 两个线程共同操作一个实例
     * @param args
     */
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

    @Override
    public void run() {
        for (int j = 0; j < 100000; j++) {
            i++;
        }
    }
}

Synchronized 的两种用法

对象锁

同步代码块锁：手动指定锁对象，锁对象默认为 this。
方法锁：synchronized 修饰普通方法，锁对象默认为 this。

类锁
Java 类会有多个对象，但只有一个 Class 对象。
类锁的本质就是 Class 对象的锁。
多个线程去访问用类锁修饰的方法的时候，他们所获取到的锁其实是 Class 对象，由于 Class 对象只有一个，所以不同的线程之间（无论该线程诞生于类的哪个实例，都只能获取到这个类唯一的 Class 对象，基于对 Class 对象的操作，形成了互斥性，即“类锁”）。
类锁只能在同一时刻被一个对象拥有。（对象锁如果是不同实例创建出来的，相互之间是没有影响的，可以同时运行）

synchronized 修饰静态方法（静态锁）
同步代码块的锁对象为 ClassName.class synchronized (Object.class)

同步代码块锁
示例：同步代码块默认使用的锁对象是 this。
synchronized 代码块

package com.xdclass.couponapp.test.synchronizeddemo;

public class SynchronizedObjectCodeBlock implements Runnable {

    static SynchronizedObjectCodeBlock instance = new SynchronizedObjectCodeBlock();
    static int num = 0;

    @Override
    public void run() {
        synchronized (this){
            System.out.println("我是对象锁的代码块形式。我叫" + Thread.currentThread().getName() );
            for (int i = 0; i < 1000000; i++) {
                num++;
            }
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println(num);
    }
}

我是对象锁的代码块形式。我叫Thread-0
Thread-0运行结束!!!!!!!!!!!!!!!!!
我是对象锁的代码块形式。我叫Thread-1
Thread-1运行结束!!!!!!!!!!!!!!!!!
2000000

示例：同步代码块：对象锁无法作用于不同的实例，不同实例之间的对象锁是互不影响的。

package com.xdclass.couponapp.test.synchronizeddemo;

/**
 * 对象锁无法作用于不同的实例
 * 不同实例之间的对象锁是互不影响的
 */
public class SynchronizedObjectCodeBlockOnDifferentInstance implements Runnable {

    static SynchronizedObjectCodeBlockOnDifferentInstance instance1 = new SynchronizedObjectCodeBlockOnDifferentInstance();
    static SynchronizedObjectCodeBlockOnDifferentInstance instance2 = new SynchronizedObjectCodeBlockOnDifferentInstance();

    Object lock1 = new Object();
    Object lock2 = new Object();

    @Override
    public void run() {
        synchronized (lock1){
            System.out.println("我是lock1同步代码块。我叫" + Thread.currentThread().getName() );
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("lock1-" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
        }
        synchronized (lock2){
            System.out.println("我是lock2同步代码块。我叫" + Thread.currentThread().getName() );
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("lock2-" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("运行结束");
    }
}

synchronized 修饰普通方法，我叫Thread-1
synchronized 修饰普通方法，我叫Thread-0
Thread-1运行结束！！！！！！
Thread-0运行结束！！！！！！
运行结束

示例：多个同步代码块，可以使用不同的锁对象，更细粒度的锁。提高整个业务方法中代码的并行比例。更有效的利用硬件资源。

package com.xdclass.couponapp.test.synchronizeddemo;

/**
 * 同一个业务方法中 可以存在多个同步代码块
 * 多个同步代码块根据特务特性可以使用不同的锁对象进行细粒度的锁
 * 提高整个业务方法中代码的并行比例
 * 更有效的利用硬件资源
 */
public class SynchronizedObjectCodeBlock implements Runnable {

    static SynchronizedObjectCodeBlock instance = new SynchronizedObjectCodeBlock();
    Object lock1 = new Object();
    Object lock2 = new Object();

    @Override
    public void run() {
        synchronized (lock1){
            System.out.println("我是lock1同步代码块。我叫" + Thread.currentThread().getName() );
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("lock1-" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
        }
        synchronized (lock2){
            System.out.println("我是lock2同步代码块。我叫" + Thread.currentThread().getName() );
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("lock2-" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("运行结束");
    }
}

我是lock1同步代码块。我叫Thread-0
lock1-Thread-0运行结束!!!!!!!!!!!!!!!!!
我是lock2同步代码块。我叫Thread-0
我是lock1同步代码块。我叫Thread-1
lock2-Thread-0运行结束!!!!!!!!!!!!!!!!!
lock1-Thread-1运行结束!!!!!!!!!!!!!!!!!
我是lock2同步代码块。我叫Thread-1
lock2-Thread-1运行结束!!!!!!!!!!!!!!!!!
运行结束

方法锁
synchronized 修饰普通方法，锁对象默认为 this。

package com.xdclass.couponapp.test.synchronizeddemo;

public class SynchronizedObjectMethod implements Runnable {
    static SynchronizedObjectMethod instance = new SynchronizedObjectMethod();

    @Override
    public void run() {
        method();
    }

    public synchronized void method(){
        System.out.println("synchronized 修饰普通方法，我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束！！！！！！");
    }


    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("运行结束");
    }
}

synchronized 修饰普通方法，我叫Thread-0
Thread-0运行结束！！！！！！
synchronized 修饰普通方法，我叫Thread-1
Thread-1运行结束！！！！！！
运行结束

静态锁（synchronized 修饰静态方法）

package com.xdclass.couponapp.test.synchronizeddemo;

/**
 * 类锁第一形式：static synchronized 返回值类型 方法名(){ }
 */
public class SynchronizedClassStaticMethod implements Runnable {
    static SynchronizedClassStaticMethod instance1 = new SynchronizedClassStaticMethod();
    static SynchronizedClassStaticMethod instance2 = new SynchronizedClassStaticMethod();

    @Override
    public void run() {
        method();
    }

    public static synchronized void method(){
        System.out.println("我是类锁的第一种形式：static method" + Thread.currentThread().getName() );
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }


    public static void main(String[] args) {
        //不同的实例：会争抢唯一的类锁
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("运行结束");
    }
}

我是类锁的第一种形式：static methodThread-0
Thread-0运行结束!!!!!!!!!!!!!!!!!
我是类锁的第一种形式：static methodThread-1
Thread-1运行结束!!!!!!!!!!!!!!!!!
运行结束

同步代码块的锁对象为 ClassName.class synchronized (Object.class)

package com.xdclass.couponapp.test.synchronizeddemo;

import static com.xdclass.couponapp.test.synchronizeddemo.SynchronizedClassStaticMethod.instance1;

/**
 *  类锁第二种形式(同步代码块锁对象是 ClassName.class)：synchronized (Object.class){}
 */
public class SynchronizedClass4Class implements Runnable {
    static SynchronizedClass4Class instance1 = new SynchronizedClass4Class();
    static SynchronizedClass4Class instance2 = new SynchronizedClass4Class();

    @Override
    public void run() {
        method();
    }

    private void method(){
        synchronized (SynchronizedClass4Class.class){
            System.out.println("我是类锁的第二种形式：同步代码块的锁对象为 ClassName.class，我叫" + Thread.currentThread().getName() );
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
        }
    }

    public static void main(String[] args) {
        //不同的实例：会争抢唯一的类锁
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
//        t1.join();
//        t2.join();
        while (t1.isAlive() || t2.isAlive()) {
        }
        System.out.println("运行结束");
    }
}

我是类锁的第二种形式：同步代码块的锁对象为 ClassName.class，我叫Thread-0
Thread-0运行结束!!!!!!!!!!!!!!!!!
我是类锁的第二种形式：同步代码块的锁对象为 ClassName.class，我叫Thread-1
Thread-1运行结束!!!!!!!!!!!!!!!!!
运行结束

多线程访问同步方法的 7 种情况

两个线程同时访问一个对象的同步方法。
线程安全的，锁对象为this，交替执行
两个线程访问的是两个对象的同步方法。
两个线程的锁对象分别是各自实例（this），互不影响，线程不安全
两个线程访问的是 synchronized 的静态方法。
synchronized 修饰静态方法属于类级别的锁，锁对象是该类的 ClassName.class 实例，锁的作用范围是该类的所有实例。多个实例抢占同一把锁，线程安全。
两个线程同时访问同一个对象同步方法与非同步方法。
两个线程可以同时运行，synchronized 关键字只作用于被修饰的方法，非同步方法则失效

/**
 * 多线程同时访问 同步方法 和 非同步方法
 */
public class SynchronizedYesAndNo implements Runnable {
    static SynchronizedYesAndNo instance = new SynchronizedYesAndNo();
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            method1();
        } else {
            method2();
        }
    }

    public synchronized void method1(){
        System.out.println("我是同步方法。我叫" + Thread.currentThread().getName() );
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("同步方法" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    public void method2(){
        System.out.println("我是非同步方法。我叫" + Thread.currentThread().getName() );
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("非同步方法" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");
    }
}

我是同步方法。我叫Thread-0		.......同时打印出
我是非同步方法。我叫Thread-1		.......同时打印出
非同步方法Thread-1运行结束!!!!!!!!!!!!!!!!!
同步方法Thread-0运行结束!!!!!!!!!!!!!!!!!
finished

多线程访问同一个对象的不同的同步方法
不同同步方法使用同一个锁对象this，因此无法并行。

package com.xdclass.couponapp.test.synchronizeddemo;

public class SynchronizedYesAndYesAndDiff implements Runnable {
    static SynchronizedYesAndYesAndDiff instance = new SynchronizedYesAndYesAndDiff();
    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            method1();
        } else {
            method2();
        }
    }

    public synchronized void method1(){
        System.out.println("我是同步方法1。我叫" + Thread.currentThread().getName() );
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("同步方法1" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    public synchronized void method2(){
        System.out.println("我是同步方法2。我叫" + Thread.currentThread().getName() );
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("同步方法2" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");
    }
}

我是同步方法1。我叫Thread-0
同步方法1Thread-0运行结束!!!!!!!!!!!!!!!!!
我是同步方法2。我叫Thread-1
同步方法2Thread-1运行结束!!!!!!!!!!!!!!!!!
finished

多线程同时访问一个对象静态 synchronized 和非静态 synchronized 方法
可以同时运行：不同方法使用的锁对象不同，前者的锁对象是类锁，后者的锁对象是this，前者的作用范围是类的所以实例（仅作用于该方法），后者的作用域是当前实例（仅作用于该方法），两个不同的方法拥有各自的锁对象，所以互不影响。

package com.xdclass.couponapp.test.synchronizeddemo;

public class SynchronizedDiffMethod implements Runnable {
    static SynchronizedDiffMethod instance = new SynchronizedDiffMethod();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            method1();
        } else {
            method2();
        }

    }

    static synchronized void method1() {
        System.out.println("我是static同步方法。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("static同步方法" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    synchronized void method2() {
        System.out.println("我是同步方法。我叫" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我是同步方法" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("finished");
    }
}

我是static同步方法。我叫Thread-0
我是同步方法。我叫Thread-1
我是同步方法Thread-1运行结束!!!!!!!!!!!!!!!!!
static同步方法Thread-0运行结束!!!!!!!!!!!!!!!!!
finished

方法抛出异常、会释放锁。
抛出异常之后，JVM会帮忙释放当前线程持有的锁对象：throw new RuntimeException();

package com.xdclass.couponapp.test.synchronizeddemo;

/**
 * 方法抛出异常，会释放锁。
 */
public class SynchronizedException implements Runnable {
    static SynchronizedException instance = new SynchronizedException();

    @Override
    public void run() {
        if (Thread.currentThread().getName().equals("Thread-0")) {
            method1();
        } else {
            method2();
        }
    }

    public synchronized void method1(){
        System.out.println("我是同步方法1。我叫" + Thread.currentThread().getName() );
        try {
            Thread.sleep(3000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (Thread.currentThread().getName().equals("Thread-0")) {
            throw new RuntimeException(); //抛出异常之后，JVM会帮忙释放当前线程持有的锁对象
        }
        System.out.println("同步方法1" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    public synchronized void method2(){
        System.out.println("我是同步方法2。我叫" + Thread.currentThread().getName() );
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("同步方法2" + Thread.currentThread().getName() + "运行结束!!!!!!!!!!!!!!!!!");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
        while (t1.isAlive() || t2.isAlive()) {

        }
        System.out.println("finished");
    }
}

我是同步方法1。我叫Thread-0
我是同步方法2。我叫Thread-1
Exception in thread "Thread-0" java.lang.RuntimeException
	at com.xdclass.couponapp.test.synchronizeddemo.SynchronizedException.method1(SynchronizedException.java:27)
	at com.xdclass.couponapp.test.synchronizeddemo.SynchronizedException.run(SynchronizedException.java:12)
	at java.lang.Thread.run(Thread.java:748)
同步方法2Thread-1运行结束!!!!!!!!!!!!!!!!!
finished

同步方法核心思想总结

一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待（对应 1、5 种情况）。
每个实例对应有自己的一把锁，不同实例之间互不影响；例外：锁对象是 ClassName.class 以及 synchronized 修饰的是 static 方法时，类的所有实例公用同一把类锁（对应 2、3、4、6 种情况）。
无论是方法正常执行完毕或者方法抛出异常，都会释放锁（对应 7 种情况）。

Synchronized 的性质

可重入（锁）
不可中断

什么是可重入
指的是同一线程的外层函数获得锁之后，内层函数可以直接再次获取该锁。
好处：避免死锁、提升封装性（简化并发编程的难度）。
粒度：线程范围，而非调用范围。

可重入性

同一个方法是可重入的

package com.xdclass.couponapp.test.synchronizeddemo;

public class SynchronizedRecursion1 {
    int num = 0;

    /**
     * 可重入：同一个方法是可重入的，避免死锁的发生。
     */
    private synchronized void method1(){
        System.out.println("method1(),a = " + num);
        if (num == 0) {
            num++;
            method1();
            System.out.println("method1()运行结束, a = " + num);
        }
    }
    
    public static void main(String[] args) {
        SynchronizedRecursion1 instance = new SynchronizedRecursion1();
        instance.method1();
    }
}

method1(),a = 0
method1(),a = 1
method1()运行结束, a = 1

可重入不要求是同一个方法

package com.xdclass.couponapp.test.synchronizeddemo;

public class SynchronizedRecursion2 {

    /**
     * 可重入：可重入不要求是同一个方法，调用类内另外一个方法。
     * 同一个对象两个同步方法的锁对象都是this，method2()可重入
     */
    private synchronized void method1(){
        System.out.println("method1()");
        method2();
        System.out.println("method1() finished");
    }

    private synchronized void method2(){
        System.out.println("method2()");
    }

    public static void main(String[] args) {
        SynchronizedRecursion2 instance = new SynchronizedRecursion2();
        instance.method1();
    }
}

method1()
method2()
method1() finished

可重入不要求是同一个类中的方法

package com.xdclass.couponapp.test.synchronizeddemo;

public class SynchronizedRecursion3 {

    /**
     * 可重入：可重入不要求是同一个类中的方法
     */
    public synchronized void method1(){
        System.out.println("我是SuperClass method()");
    }
}

class SonClass extends SynchronizedRecursion3 {
    @Override
    public synchronized void method1() {
        System.out.println("我是SonClass method()");
        super.method1();
        System.out.println("SonClass finished.");
    }

    public static void main(String[] args) {
        SonClass sonClass = new SonClass();
        sonClass.method1();
    }
}

我是SonClass method()
我是SuperClass method()
SonClass finished.

不可中断
一旦这个锁已经被别人获得，如果我还想获得，只能选择等待或者阻塞，直到持有锁的线程释放这个锁，如果持有锁的线程一直不释放锁，只能永远等待下去。
相比之下，Lock 类拥有中断能。

* 有权中断当前持有锁的线程的执行。
* 如果等待时间太长，可以选择退出等待。

深入 synchronized 底层原理

加锁和释放锁的原理
现象
所有对象都含有互斥锁，一个线程想执行一个实例的同步方法必须先获取该实例的锁方可进入方法执行，否则需要阻塞直接获取该实例的锁。

获取和释放锁的时机（内置锁）
每一个 Java 对象都可以用于一个内置锁（monitor lock），线程进入同步代码块之前获得内置锁，退出同步代码块前释放锁（包括正常退出和抛出异常退出）。

package com.xdclass.couponapp.test.synchronizeddemo;

import javax.sound.midi.Soundbank;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 两个方法功能等价
 */
public class SynchronnizedToLock {
    Lock lock = new ReentrantLock();

    public synchronized void method1(){
        System.out.println("我是 synchronized 锁");
    }

    public synchronized void method2(){
        lock.lock();
        try {
            System.out.println("我是 lock 形式的锁");
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        SynchronnizedToLock instance = new SynchronnizedToLock();
        instance.method1();
        instance.method2();
    }
}

JVM 字节码
Java 对象头的区域中有一个字段用于标识锁状态。
每个对象都与一个 monitor 相关联，一个 monitor 的 lock 只能被一个线程在同一时间获得。
一个线程在尝试获得与对象关联的 monitor 的所有权的时候会发生以下三种情况之一（monitorenter）
monitorexit 指令是释放对于 monitor 的所有权（释放 monitor 的锁的所有权）。

# monitorenter 指令的功能
* monitor 计数器如果为0，意味着目前monitor还没有被获得，线程会立刻获得monitor，并且把计数器加一。
* monitor 已经拿到拿到 lock的所有权，又重入了，这样会导致计数器再加一。
* monitor 已经被其他线程持有，其他的线程尝试获取 monitor 则会被拒绝的信号，进入阻塞状态，直到 monitor 计数器变为0 ，才会再次尝试获取锁。

# monitorexit 指令的功能
* 将monitor 计数器减一，如果减一之后变为0，意味当前线程不再拥有对 monitor 的所有权，解锁。
* 如果减一结束之后，计数器不是0，意味着当前线程发生过重入行为，当前线程继续持有monitor（锁）。
* 当计数器最终减为0，意味着其他阻塞线程可以再次尝试获取 monitor（锁）。

# 反编译 monitorenter   monitorexit
> javac .\Decompilation.java
> javap -verbose .\Decompilation.class

    Code:
      stack=2, locals=4, args_size=2
         0: aload_0
         1: getfield      #3                  // Field object:Ljava/lang/Object;
         4: dup
         5: astore_2
         6: monitorenter
         7: aload_2
         8: monitorexit
         9: goto          17
        12: astore_3
        13: aload_2
        14: monitorexit
        15: aload_3
        16: athrow
        17: return

可重入原理
可重入的原理就是利用 monitorenter 指令的功能，加锁次数计数器加一。
每个对象天生都持有一把锁，JVM 负责跟踪该对象被加锁的次数。
线程发生重入行为之后（被相同的线程再次获得锁的时候，只有首先获得该锁的线程，才能在该对象上多次的获取这把锁），会导致加锁次数计数器的自增。
每当任务离开时，加锁次数计数器会递减，当计数器为 0 的时候，当前线程失去对该对象 monitor 的所有权（锁）。

保证可见性的原理：内存模型
线程的本地内存是为了加快访问。

A 线程将本地缓存中修改的共享变量副本同步到主内存中
JMM 负责将主线程中共享变量的最新副本同步到 B 线程的本地内存中，作为 B 线程本地内存的共享变量的最新副本。

Synchronized 是如何实现可见性的？
被 synchronized 修饰的代码块或方法在执行完毕之前，基于对象的所有修改都要在释放锁之间从线程本地内存由 JMM 控制同步到主内存中。
线程在进入同步代码块得到锁之后，被锁定对象的数据必须直接从主内存中读取（以确保读取的数据是最新的）。

保证可见性的原理：内存模型

Synchronized 缺陷

效率低

锁的释放情况少：执行完才会释放锁、执行中发生异常 JVM 会帮忙释放锁。只有前面这两种情况才会释放。（如果同步方法中代码发生 I/O 阻塞会浪费 CPU 资源）
试图获得锁时不能设定超时：不撞南墙不回头。
不能中断一个正在试图获得锁的线程：不撞南墙不回头。

不够灵活（读写锁更灵活）

加锁和释放锁的时机单一，每个锁仅有单一的条件（某给对象），可能是不够的（有一种锁叫作读写锁，加锁和释放锁的时机更加灵活，读不加锁，写加锁）。

无法知道是否成功获取到锁

Lock 可以知道是否成功获取锁，如果获取到做一些逻辑，如果没有获取到做另外一些逻辑。

Synchronized 总结

Synchronized 使用注意点

* 锁对象不能为空：锁状态信息在对象头中，如果没有对象锁无法工作。不能是空对象，必须是new()过的。
* 作用域不宜过大：synchronized包括的范围。多线程编程的根本目的是为了提高效率，如果同步范围过大，安全是安全，但是代码的并行比例太低，无法充分利用硬件资源提高程序执行效率，大部门代码都是串行化的多线程程序提升效果并不会很好。
* 避免死锁：

如何选择 Lock 和 synchronized 关键字？

* 如果可以的话，尽量不要使用 synchronized 和 Lock，尽量使用 java.util.concurrent 包中的类，使用这些类可以让开发者解脱同步的工作，更方便，也更不容易出错。
* 如果 synchronized 关键字在程序中适用，应该优先使用 synchronized 关键字，这样可以减少同步锁需要编写的代码，提高封装性。
* 在需要用到 Lock 的特性时候才使用 Lock。

多线程访问同步方法的各种情况？
7 种情况。

作者：Soulboy