并发编程-Synchronized

什么是Synchronized

synchronized是Java提供的一个关键字，Synchronized可以保证并发程序的原子性，可见性，有序性。
我们会把synchronized称为重量级锁。主要原因，是因为JDK1.6之前，synchronized是一个重量级锁相比于JUC的锁显得非常笨重，存在性能问题。JDK1.6及之后，Java对synchronized进行的了一系列优化，性能与JUC的锁不相上下。

Synchronized 使用

synchronized可以修饰方法和代码块
方法：可修饰静态方法和非静态方法
代码块：同步代码块的锁对象可以为当前实例对象、字节码对象（class）、其他实例对象

1 修饰方法普通方法
synchronized修饰普通方法，锁对象默认为this
2 修饰静态方法
锁对象为Class对象
3 代码块

synchronized (lockobj) {// 书写同步代码
}

Synchronized原理分析

public class Demo {Object lock = new Object();public synchronized void demo() {}public void execute() {synchronized (lock) {System.out.println("get lock");}}
}

javac Demo.java
javap -c Demo.class

 public synchronized void syncMethod();Code:0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;3: ldc           #5                  // String get lock5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V8: returnpublic void executeMethod();Code:0: aload_01: getfield      #3                  // Field lock:Ljava/lang/Object;4: dup5: astore_16: monitorenter7: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;10: ldc           #5                  // String get lock12: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V15: aload_116: monitorexit17: goto          2520: astore_221: aload_122: monitorexit23: aload_224: athrow25: return

从上述字节码指令看的到，同步代码块和同步方法的字节码是不同的：
对于synchronized同步块，对应的monitorenter和monitorexit指令分别对应synchronized同步块的进入和退出。
为什么会多一个monitorexit？编译器会为同步块添加一个隐式的try-finally，在finally中会调用monitorexit命令释放锁
对于synchronized方法，对应ACC_SYNCHRONIZED关键字，JVM进行方法调用时，发现调用的方
法被ACC_SYNCHRONIZED修饰，则会先尝试获得锁，方法调用结束了释放锁。在JVM底层，对于这两种synchronized的实现大致相同。都是基于monitorenter和monitorexit指令实现，底层还是使用 标记字段MarkWord和Monitor（管程）来实现重量级锁。
什么是管程？
Monitor中文翻译为管程，也有人称之为“监视器”，管程指的是管理共享变量以及对共享变量的操作过程，让他们支持并发。
Java中的所有对象都可以作为锁，每个对象都与一个 monitor 相关联，线程可以对 monitor 执行lock 和 unlock 操作。
Java并没有把lock和unlock操作直接开放给用户使用，但是却提供了两个指令来隐式地使用这两个操作：moniterenter和moniterexit。moniterenter对应lock操作，moniterexit对应unlock操作，通过这两个指锁定和解锁 monitor 对象来实现同步。
当一个monitor对象被线程持有后，它将处于锁定状态。对于一个 monitor 而言，同时只能有一个线程能锁定monitor，其它线程试图获得已被锁定的 monitor时，都将被阻塞。当monitor被释放后，阻塞中的线程会尝试获得该 monitor锁。一个线程可以对一个 monitor 反复执行 lock 操作，对应的释放锁时，需要执行相同次数的 unlock 操作。
管程相关文档：
https://www.cnblogs.com/binarylei/p/12544002.html#2-%E7%AE%A1%E7%A8%8Bmonitor

Synchronized锁升级

在JDK1.6之后同步锁一共有四种状态，级别从低到高依次是：无锁，偏向锁，轻量级锁，重量级锁。这四种状态
会随着竞争激烈情况逐渐升级。
偏向锁(需要运行时间在5-6s以上JVM才会开启)
只有一个线程访问锁资源（无竞争）的话，偏向锁就会把整个同步措施都消除，并记录当前持有锁资源的线程和锁的型。
轻量级锁
轻量级锁是基于这样一个想法：只有两个线程交替运行时，如果线程竞争锁失败了，先不立即挂起，而是让它飞一会儿（自旋），在等待过程中，可能锁就被释放了，这时该线程就可以重新尝试获取锁，同时记录持有锁资源的线程和锁的类型。
有关锁的信息都是object对象头中markdown来保存的

锁升级过程演示：
对象头怎么看每一位的含义可以看这篇博客

public class Demo {public static void main(String[] args) throws InterruptedException {// 为了开启偏向锁Thread.sleep(5001);Object lock = new Object();// 偏向锁 110printObj(lock, 1);// 都在main线程里面所以还是偏向锁synchronized (lock) {printObj(lock, 2);}// 再开一个线程进行资源争抢new Thread(() -> {synchronized (lock) {System.out.println("get lock one");// 升级成为了轻量级锁 00printObj(lock, 3);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}).start();// 再开一个线程进行资源争抢new Thread(() -> {synchronized (lock) {System.out.println("get lock two");}}).start();// 少量竞争轻量级锁 00printObj(lock, 4);// 让上面的线程结束 然后开始疯狂竞争// 竞争非常的激烈会升级成重量级锁 10Thread.sleep(2000);for (int i = 0; i < 10; i ++) {new Thread(() -> {synchronized (lock) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("get lock three");}}).start();}printObj(lock, 5);}static void printObj(Object o, int i) {String s = ClassLayout.parseInstance(o).toPrintable();System.out.println(s + " " + i);}
}

java.lang.Object object internals:OFFSET  SIZE   TYPE DESCRIPTION                               VALUE0     4        (object header)                           05 00 00 00 (00000101 00000000 00000000 00000000) (5)4     4        (object header)                           00 00 00 00 (00000000 00000000 00000000 00000000) (0)8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total1
java.lang.Object object internals:OFFSET  SIZE   TYPE DESCRIPTION                               VALUE0     4        (object header)                           05 d8 aa 05 (00000101 11011000 10101010 00000101) (95082501)4     4        (object header)                           e4 01 00 00 (11100100 00000001 00000000 00000000) (484)8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total2
get lock one
java.lang.Object object internals:OFFSET  SIZE   TYPE DESCRIPTION                               VALUE0     4        (object header)                           c8 ed 5f ad (11001000 11101101 01011111 10101101) (-1386222136)4     4        (object header)                           b5 00 00 00 (10110101 00000000 00000000 00000000) (181)8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total3
java.lang.Object object internals:OFFSET  SIZE   TYPE DESCRIPTION                               VALUE0     4        (object header)                           c8 ed 5f ad (11001000 11101101 01011111 10101101) (-1386222136)4     4        (object header)                           b5 00 00 00 (10110101 00000000 00000000 00000000) (181)8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total4
get lock two
java.lang.Object object internals:OFFSET  SIZE   TYPE DESCRIPTION                               VALUE0     4        (object header)                           ba 71 b5 05 (10111010 01110001 10110101 00000101) (95777210)4     4        (object header)                           e4 01 00 00 (11100100 00000001 00000000 00000000) (484)8     4        (object header)                           e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total5