概念

运用synchronize同步关键字可以完成线程之间的同步，保证多个线程的一起操作下的数据安全。可是 synchronize是一个重量级操作，比方下面的事例：

public class Main {
    private int i = 0;
    /**
     * 
     */
    public void setValue() {
        synchronized (this) {
            i++;
        }
    }
}

同步代码块中只要++操作,实践上它的资源占用很少，可是假如在多个线程之间进行互斥等候的话，那么CPU就要在多个线程之间来回切换，原本一件很简单的++操作,在线程之间相互等候却占用了比实践的操作更多的时间。

原理

在了解原理之前，首要要知道java目标在内存中的布局，分为3个部分：

目标头
实例数据
对其填充

当咱们new一个java目标时，JVM会在堆中创建出一个instanceOopDesc目标，它就包含了目标头以及实例数据。

它的首要两个部分为：_metadata 和 _mark。

_metadata首要保存了类的元数据。今日要了解的重点则是 _mrak,咱们可以称之为符号字段。它其间首要保存了目标的 hashCode , 分代年纪，锁标志位，是否倾向锁。 _mark的默认结构如下：

由于默认状况下没有线程占用该目标，所以锁的状况是 无锁。考虑到JVM的空间功率，它被规划为非固定的数据结构，除了以上的固定结构之外，还有：

上图都是在各种状况下_mardk字段的结构.

Java中的锁分为以下几种状况：

GC符号为 GC收回算法有关，本文无需关怀。需求留意的是锁的几种类型：

无锁
倾向锁
轻量级锁
重量级锁

重量级锁

咱们熟知的synchronize便是重量级锁，它会引起CPU的在用户态和内核态之间来回切换。当一个目标的锁状况为重量级锁（标志位 10）时，

_markdatra 会用30bit记载一个指向互斥锁（monitor）的指针。

monitor的结构

monitir可以看理解为一个同步工具，或者描绘为一种同步机制。实践上它是保存在目标头中的一个目标。这里咱们只需求知道，java中每一个目标都有一个自己的ObjectMonitor目标，翻译为：目标监视器

这也便是java中的一切Object及其子类目标都可以作为 锁 的原因.

ObjectMonitor的结构

留意其间的几个关键字段：

字段名	意义
`_EntrySet`	存放等候锁的`block`状况的线程行列
`_owner`	指向持有锁目标的线程
`_count`	当某个线程竞赛到monitor之后，
`_recursions`	锁的重入次数
`_WaitSet`	存放等候锁的`wait`状况的线程行列

当多个线程一起访问一段同步代码时，首要他们会进入到_entrySet，当某个线程竞赛到monitor之后，_owner会变为当时线程，_count会+1，表明线程现已取得当时锁。

假如持有monitor的线程调用wait办法, 它将会开释锁，_owner会变成 null，_count会自减。一起该线程会进入到 _WaitSet等候被唤醒。假如持有monirot的线程履行任务结束，相同也会开释锁，_owner会变成 null，_count会自减，以便其他线程进入获取锁目标。

实例演示

假如3个线程一起履行 syncMethod办法，模仿状况如下：

履行之前

开端竞赛锁

此刻，3个线程都进了 EntrySet

线程2抢到了锁

Owner会指向线程2，一起count++

线程2履行进程中调用了wait

此刻，count–，Owner变成 null，线程2进入到WaitSet行列

线程1取得了锁，并且在履行进程调用了 notify

线程2会被从头添加到 EntrySet，并测验从头获取锁。可是，线程1调用notify并不会开释锁。

ObjectMonitor目标监视器同步机制

它是JVM对系统等级的互斥锁（MutexLock）的办理进程。期间都会转入到系统内核态。所以，synchronize完成锁，是根据重量级锁的状况下。当多个线程切换上下文时，是一个很重量级的操作。

经典的生产顾客形式事例代码

用wait和notify确保多线程的数据安全。

import java.util.LinkedList;
class ProducerConsumer {
    private LinkedList<Integer> buffer = new LinkedList<>();
    private int capacity = 5;
    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                while (buffer.size() == capacity) {
                    wait();
                }
                System.out.println("Producer produced: " + value);
                buffer.add(value++);
                notify();
                Thread.sleep(1000);
            }
        }
    }
    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                while (buffer.isEmpty()) {
                    wait();
                }
                int value = buffer.removeFirst();
                System.out.println("Consumer consumed: " + value);
                notify();
                Thread.sleep(1000);
            }
        }
    }
}
public class Main {
    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        Thread producerThread = new Thread(() -> {
            try {
                pc.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread consumerThread = new Thread(() -> {
            try {
                pc.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        producerThread.start();
        consumerThread.start();
    }
}

JVM对Synchronize的优化

从java6开端，JVM开端对synchronize做出优化，首要意图是减少对 ObjectMonitor的访问，减少对重量级锁的运用，终究减少上下文切换的频率。

锁自旋

自旋锁是一种线程同步机制，它在等候共享资源开释的时候，并不会让线程进入睡眠或堵塞状况，而是让线程处于忙等（自旋）状况，即不断地循环查看共享资源是否可用。这样可以减少线程状况的切换和上下文切换的开支，进步程序的履行功率。

那么，JVM引进自旋锁的终极意图是为了在多核CPU中更好地使用硬件特性，进步多线程程序的履行功率。当线程在自旋锁上自旋等候时，它会尽可能地使用闲暇的CPU时间履行自旋操作，以等待共享资源的快速开释。这对于一些短时间的等候是非常有用的，因为在这种状况下，睡眠或堵塞线程的开支可能超过了等候的时间。

总而言之，JVM引进自旋锁的终极意图是经过减少线程状况切换和上下文切换的开支，进步多线程程序的功能和响应性，使程序可以更好地使用多核CPU的硬件特性。

缺陷便是：需求占用CPU。

轻量级锁

JVM中存在一些极点状况，对于一个同步代码块，不同线程是在不同的时间段去替换恳求这把锁，不存在竞赛的状况。就像一个很有纪律的食堂，规规矩矩排队打饭，而不是抢着打饭。或者一个公路上合流的入口，一切车子都很有默契地替换同行，而不是抢行。在这种状况下，锁会坚持轻量级锁的状况，从而避免重量级锁的上下文切换。

完成方法如下：

轻量级锁的标志位为： 00, 当一个线程去履行同步代码块时，JVM会在当时线程的栈帧中创建出一个LockRecord记载，并将锁目标的Mark拷贝到栈帧中。也便是说，锁目标的markWord现已指向了这个线程。

当线程再次履行同步代码块时，判断当时锁的markWord是否指向当时线程的栈帧，假如是，则直接履行同步代码块。

假如不是，轻量级锁就膨胀为重量级锁，留意，这仅仅适用于多个线程替换取得锁，无竞赛的状况。

倾向锁

比轻量级锁愈加极点的状况为，不仅仅没有多线程一起竞赛，反而只要一个线程一直在履行一段同步代码块，此刻，为了让线程取得锁的价值更低，

完成方法为：锁目标头中有一个ThreadId字段，当第一次取得锁的时候，将这个字段设置为该线程的id，下次获取锁的时候，直接查看id是否共同即可，假如共同，则以为现已取得了锁，则不需求再次取得。

这归于很极点的状况，一旦呈现锁竞赛，倾向锁就会被撤销，这是一个重量级的操作，此刻，倾向锁会膨胀为轻量级锁。。

所谓JVM调优，很多都是在多线程的场景下，根据业务决议是否敞开倾向锁，轻量级锁，调整 JVM参数，来到达最契合当时实践状况的功能。

总结

倾向锁和轻量级锁都是经过自旋来避免真正的加锁
重量级锁是取得锁和开释锁
重量级锁是经过目标内部的监视器 ObjectMonitor完成

九、synchronize实现原理

概念

原理

重量级锁

monitor的结构

ObjectMonitor的结构

实例演示