本文核心点

• synchronized是非公平的锁！
• 有线程在执行，新进入的线程会进入这个cxq这个队列中！
• 本文释放锁分析使用的是默认策略（QMode=0）：如果EntryList为空，则将cxq中的元素按原有顺序插入到EntryList，并唤醒第一个线程，也就是当EntryList为空时，是后来的线程先获取锁。_EntryList不为空，直接从_EntryList中唤醒线程。

synchronized到底是什么？

• synchronized是JVM内置锁，基于Monitor机制实现。
• 依赖底层操作系统的互斥原语Mutex（互斥量）。
• 表面上它是一个重量级锁，性能较低。
• 实际上JVM内置锁在1.5之后版本做了重大的优化，如锁粗化（Lock Coarsening）、锁消除（Lock Elimination）、轻量级锁（Lightweight Locking）、偏向锁（Biased Locking）、自适应自旋（Adaptive Spinning）等技术来减少锁操作的开销，内置锁的并发性能已经基本与Lock持平。

Monitor（管程/监视器）

• Monitor，直译为“监视器”，而操作系统领域一般翻译为“管程”。
• 管程是指管理共享变量以及对共享变量操作的过程，让它们支持并发。
• synchronized关键字和wait()、notify()、notifyAll()这三个方法是Java中实现管程技术的组成部分。

管程模型

• 在管程的发展史上，先后出现过三种不同的管程模型，分别是Hasen模型、Hoare模型和MESA模型。
• 现在正在广泛使用的是MESA模型。

wait()、notify()和notifyAll()的使用

• 使用wait有个范式要求：while(条件不满足) {  wait(); }
• 所有等待线程拥有相同的等待条件：使用notify()。
• 所有等待线程被唤醒后，执行相同的操作：使用notify()。
• 只需要唤醒一个线程：使用notify()。
• 其他时候尽量使用notifyAll()。

Java内置的管程：synchronized

• Java 参考了 MESA 模型，语言内置的管程（synchronized）对 MESA 模型进行了精简。
• MESA 模型中，条件变量可以有多个，Java 语言内置的管程里只有一个条件变量。

Monitor机制在Java中的实现

• java.lang.Object 类定义了 wait()，notify()，notifyAll() 方法
• wait()，notify()，notifyAll()的具体实现，依赖于 ObjectMonitor（JVM内部的机制） 实现。

ObjectMonitor的主要数据结构

    _header       = NULL; //对象头  markOop
    _count        = 0;  
    _waiters      = 0,   
    _recursions   = 0;   // synchronized是一个重入锁，这个变量记录锁的重入次数 
    _object       = NULL;  //存储锁对象
    _owner        = NULL;  // 标识拥有该monitor的线程（当前获取锁的线程） 
    _WaitSet      = NULL;  // 调用wait阻塞的线程：等待线程组成的双向循环链表，_WaitSet是第一个节点
    _WaitSetLock  = 0 ;    
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ; // 有线程在执行，新进入的线程会进入这个队列：多线程竞争锁会先存到这个单向链表中 （FILO栈结构：非公平！）
    FreeNext      = NULL ;
    _EntryList    = NULL ; //存放在进入或重新进入时被阻塞(blocked)的线程 (也是存竞争锁失败的线程)
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;

synchronized的等待唤醒机制

• 在获取锁时，是将当前线程插入到cxq的头部。
• 在释放锁时默认策略（QMode=0）:如果EntryList为空，则将cxq中的元素按原有顺序插入到EntryList，并唤醒第一个线程，也就是当EntryList为空时，是后来的线程先获取锁。_EntryList不为空，直接从_EntryList中唤醒线程。

synchronized下线程的执行流程：等待机制！

• 看一段代码的执行结果

public class SyncQModeDemo {

	public static void main(String[] args) throws InterruptedException {

		SyncQModeDemo demo = new SyncQModeDemo();

		demo.startThreadA();
		// 控制线程执行时间
		Thread.sleep(100);
		demo.startThreadB();
		Thread.sleep(100);
		demo.startThreadC();
	}

	final Object lock = new Object();

	public void startThreadA() {
		new Thread(() -> {
			synchronized (lock) {
				log.debug("A get lock");
				try {
					lock.wait(300);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				log.debug("A release lock");
			}
		}, "thread-A").start();
	}

	public void startThreadB() {
		new Thread(() -> {
			synchronized (lock) {
				try {
					log.debug("B get lock");
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				log.debug("B release lock");
			}
		}, "thread-B").start();
	}

	public void startThreadC() {
		new Thread(() -> {
			synchronized (lock) {

				log.debug("C get lock");
			}
		}, "thread-C").start();
	}
}

执行结果

• A get lock
• B get lock
• B release lock
• A release lock
• C get lock

为什么是这样的结果？

• 第一个线程正常执行：owner是第一个线程！
• 第二个线程进来，由于第一个在执行，他会阻塞：owner是第一个线程，cxq有第二个线程！
• 假设这时候线程一调用wait()方法：WaitSet有第一个线程，cxq有第二个线程！owner为空！
• 下一次进行争抢线程的使用权，EntryList是空的，cxq中的第线程去执行：WaitSet有第一个线程，owner是第二个线程！
• 这时候第三个线程进来：cxq有第三个线程，WaitSet有第一个线程，cxq有第三个线程！owner是第二个线程！
• 第二个线程执行完毕，唤醒其他线程，将WaitSet中的线程转移到EntryList：EntryList有第一个线程，cxq有第三个线程！
• 下一次进行争抢线程的使用权，EntryList有值，直接从EntryList里面唤醒线程：EntryList有第一个线程，owner是第一个线程！
• 第一个线程执行完毕，唤醒线程，只有cxq里面有线程，唤醒他：owner是第三个线程。

synchronized下线程的执行流程：竞争机制

• 看一段代码的执行结果

public class SyncQModeDemo {

	public static void main(String[] args) throws InterruptedException {

		SyncQModeDemo demo = new SyncQModeDemo();

		demo.startThreadA();
		// 控制线程执行时间
		Thread.sleep(100);
		demo.startThreadB();
		Thread.sleep(100);
		demo.startThreadC();
	}

	final Object lock = new Object();

	public void startThreadA() {
		new Thread(() -> {
			synchronized (lock) {
				log.debug("A get lock");
				try {
					Thread.sleep(300);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				log.debug("A release lock");
			}
		}, "thread-A").start();
	}

	public void startThreadB() {
		new Thread(() -> {
			synchronized (lock) {
				try {
					log.debug("B get lock");
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				log.debug("B release lock");
			}
		}, "thread-B").start();
	}

	public void startThreadC() {
		new Thread(() -> {
			synchronized (lock) {

				log.debug("C get lock");
			}
		}, "thread-C").start();
	}
}

执行结果

• A get lock
• A release lock
• C get lock
• B get lock
• B release lock

为什么是这样的结果？

• 第一个线程正常执行：owner是第一个线程！
• 第一个线程没执行完，第二个线程进来：owner是第一个线程！cxq中有第二个线程！
• 第一个线程没执行完，第三个线程进来：owner是第一个线程！cxq中有第二个线程，第三个线程（队列结构，第二个线程先进来，第三个线程后进来）！
• 第一个线程执行完，原顺序从cxq中转移线程到EntryList：EntryList中有第二个线程，第三个线程（队列结构，第二个线程先进来，第三个线程后进来）！
• 唤醒线程：owner是第三个线程！cxq中有第二个线程！
• 线程三执行完：唤醒第二个线程，执行！

结束语

• 获取更多有价值的文章，让我们一起成为架构师！
• 关注公众号，可以让你对MySQL有非常深入的了解
• 关注公众号，每天持续高效的了解并发编程！
• 这个公众号，无广告！！！每日更新！！！