synchronized底层浅析（一）

之前说过hashMap，我们知道hashMap是一种非线程安全的集合，主要原因是它在多线程的情况下，插入、删除、扩容的时候容易导致数据丢失或者链表环

那我们也知道ConcurrentHashMap、hashTable是线程安全的，我们看hashTable的源码时，会发现源码中很多方法都是加了synchronized 关键字的那我们今天就来分析下synchronized 关键字的使用场景及如何起作用。

使用场景：

synchronized关键字最主要有以下3种应用方式

1.修饰普通方法，作用于当前实例加锁，进入同步方法前要获得当前实例的锁

public class SynchronizedTest implements Runnable{

    static int i =0;

    public synchronized void increase(){

        System.out.println(i++);

        System.out.println("进入增加方法："+Thread.currentThread().getName());

    }

    @Override

    public void run() {

　　　　　System.out.println(Thread.currentThread().getName()+"在执行");

        for(int j=0;j<10;j++){

            System.out.println("即将进入增加方法："+Thread.currentThread().getName());

            increase();

        }

    }

    public static void main(String[] args) {

        SynchronizedTest test1 = new SynchronizedTest();

        Thread thread1 = new Thread(test1);

        Thread thread2 = new Thread(test1);

        Thread thread3 = new Thread(test1);

        Thread thread4 = new Thread(test1);

        thread1.start();

        thread2.start();

        thread3.start();

        thread4.start();

    }

　　//结果为线程名称乱序

}

也就是说如果两个线程，线程A 和线程B 同时执行对于同一个对象而言，能够同时进入非 synchronized声明的方法，但是如果这个方法中调用了 synchronized声明的方法，则将会进行线程抢占，同一时间只有一个线程能够拿到进入这个方法的锁。

这里注意：它的锁的范围是这个对象中的这个方法。

2.修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁

public class SynchronizedTest implements Runnable{

    static int i =0;

    public static synchronized void increase(){

        System.out.println(i++);

        System.out.println("进入增加方法："+Thread.currentThread().getName());

    }

    @Override

    public void run() {

        System.out.println(Thread.currentThread().getName()+"在执行");

        for(int j=0;j<10;j++){

            System.out.println("即将进入增加方法："+Thread.currentThread().getName());

            increase();

        }

    }

    public static void main(String[] args) {

        SynchronizedTest test1 = new SynchronizedTest();

        Thread thread1 = new Thread(test1);

        Thread thread2 = new Thread(test1);

        Thread thread3 = new Thread(test1);

        Thread thread4 = new Thread(test1);

        thread1.start();

        thread2.start();

        thread3.start();

        thread4.start();

    }

}

注意：该锁对象是Class实例，因为静态方法存在于永久代，因此静态方法锁相当于该类的一个全局锁；

3.修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁

public class SynchronizedTest implements Runnable{

    static SynchronizedTest synchronizedTest = new SynchronizedTest();

    static int i =0;

    @Override

    public void run() {

        System.out.println(Thread.currentThread().getName()+"准备执行");

        for(int j=0;j<10;j++){

            System.out.println("即将进入增加方法："+Thread.currentThread().getName());

            try {

                Thread.sleep(1000L);

            } catch (Exception e) {

            }

            synchronized (synchronizedTest){

                System.out.println(Thread.currentThread().getName()+"执行中");

                i++;

            }

        }

    }

    public static void main(String[] args) {

        Thread thread1 = new Thread(synchronizedTest);

        Thread thread2 = new Thread(synchronizedTest);

        Thread thread3 = new Thread(synchronizedTest);

        Thread thread4 = new Thread(synchronizedTest);

        Thread thread5 = new Thread(synchronizedTest);

        Thread thread6 = new Thread(synchronizedTest);

        thread1.start();

        thread2.start();

        thread3.start();

        thread4.start();

        thread5.start();

        thread6.start();

    }

}

这种就是对进入synchronize代码块的对象加锁，也是对象锁。

我们再来看下把这些代码反编译之后出现的指令：

我们可以看到明显的monitorenter和monitorexit命令，还有一些是在方法维度有ACC_SYNCHRONIZED

其实这个关键字是同monitorenter和monitorexit命令是一样的，当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取monitor，获取成功之后才能执行方法体，方法执行完后再释放monitor。在方法执行期间，其他任何线程都无法再获得同一个锁。

我们先说下这两个命令的工作方式：

monitorenter：每个对象都是一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：
1. 如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者；
2. 如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1；
3. 如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权；
monitorexit：执行monitorexit的线程必须是objectref所对应的monitor的所有者。指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

monitorexit指令出现了两次，第1次为同步正常退出释放锁；第2次为发生异步退出释放锁；

我们先说下monitor，我们认为每个java对象都有一种天生的锁属性，那么这个锁属性是体现在哪里的呢？那我们就来看下在JVM中对象是怎么样的？

(来自于：https://www.jianshu.com/p/e62fa839aa41)

如图：

　　java的对象可以分为三个部分：对象头、实例数据、对齐填充

　　实例数据中存储的就是：存放类的属性数据信息，包括父类的属性信息

　　对齐信息：由于HotSpot规定对象的大小必须是8的整数倍，而对象头刚好是8的整数倍，如果对象实例数据这部分不是的话，就需要占位符对齐填充。

　　最后说下最重要的对象头：对象头包含如下信息

　　　　Mark Word（标记字段）：这里包含了很多重要的信息，比如：哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程 ID、偏向时间戳等我们把这里分为两块来说，下一次会主要讲这里因为锁状态的变化这里的改变。

　　　　Klass Pointe（类型指针）：对象指向它的类元数据的指针，JVM通过这个指针确定该对象是哪个类的实例。

　　　　Array Length（数组长度）：只有在对象是个数据的前提下才有这个信息，否则没有。

- 普通对象包含：Mark Word、Klass Pointer
- 数组对象包含：Mark Word、Klass Pointer、Array Length

Mark Word 这个部分在32位下是32bit，在64位下是64bit 但是不论其他结构如何，最后两位一定标识的是锁的状态，我们先观察最后这两位：

32位JVM

存储内容(30bit)	锁状态(2bit)
identify_hashcode:25 \| age:4 \| biased_lock:1	(01)无锁
threadId:23 \| age:4 \| epoch:2 \| biased_lock:1	(01)偏向锁
ptr_to_lock_record:30	(00)轻量级锁
ptr_to_heavyweight_monitor:30	(10)重量级锁
gc_info:30	(11)GC标记

64位JVM

存储内容(62bit)	锁状态(2bit)
unused:25 \| identify_hashcode:25 \| unused:1 \| age:4 \| biased_lock:1	(01)无锁
threadId:54 \| epoch:2 \| unused:1 \| age:4 \| biased_lock:1	(01)偏向锁
ptr_to_lock_record:62	(00)轻量级锁
ptr_to_heavyweight_monitor:62	(10)重量级锁
gc_info:62	(11)GC标记

当MarkWord锁标识位为10，其中指针指向的是Monitor对象的起始地址。

在Java虚拟机（HotSpot）中，Monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的）：

ObjectMonitor() {

    _header       = NULL;

    _count        = 0; // 记录个数

    _waiters      = 0,

    _recursions   = 0;

    _object       = NULL;

    _owner        = NULL;

    _WaitSet      = NULL; // 处于wait状态的线程，会被加入到_WaitSet

    _WaitSetLock  = 0 ;

    _Responsible  = NULL ;

    _succ         = NULL ;

    _cxq          = NULL ;

    FreeNext      = NULL ;

    _EntryList    = NULL ; // 处于等待锁block状态的线程，会被加入到该列表

    _SpinFreq     = 0 ;

    _SpinClock    = 0 ;

    OwnerIsThread = 0 ;

  }

ObjectMonitor中有两个队列，_WaitSet 和 _EntryList，用来保存ObjectWaiter对象列表（ 每个等待锁的线程都会被封装成ObjectWaiter对象 ），_owner指向持有ObjectMonitor对象的线程，当多个线程同时访问一段同步代码时：

首先会进入 _EntryList 集合，当线程获取到对象的monitor后，进入 _Owner区域并把monitor中的owner变量设置为当前线程，同时monitor中的计数器count加1；

若线程调用 wait() 方法，将释放当前持有的monitor，owner变量恢复为null，count自减1，同时该线程进入 WaitSet集合中等待被唤醒；

若当前线程执行完毕，也将释放monitor（锁）并复位count的值，以便其他线程进入获取monitor(锁)；

同时，Monitor对象存在于每个Java对象的对象头Mark Word中（存储的指针的指向），

通过上面描述，我们应该能很清楚的看出Synchronized的实现原理，Synchronized的语义底层是通过一个monitor的对象来完成，其实wait/notify等方法也依赖于monitor对象，这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法，否则会抛出java.lang.IllegalMonitorStateException的异常的原因。