并发编程-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 lock
       5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public void executeMethod();
    Code:
       0: aload_0
       1: getfield      #3                  // Field lock:Ljava/lang/Object;
       4: dup
       5: astore_1
       6: monitorenter
       7: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      10: ldc           #5                  // String get lock
      12: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      15: aload_1
      16: monitorexit
      17: goto          25
      20: astore_2
      21: aload_1
      22: monitorexit
      23: aload_2
      24: athrow
      25: 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();
        // 偏向锁 110
        printObj(lock, 1);
        // 都在main线程里面所以还是偏向锁
        synchronized (lock) {
            printObj(lock, 2);
        }
        // 再开一个线程进行资源争抢
        new Thread(() -> {
            synchronized (lock) {
                System.out.println("get lock one");
                // 升级成为了轻量级锁 00
                printObj(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();
        // 少量竞争轻量级锁 00
        printObj(lock, 4);
        // 让上面的线程结束 然后开始疯狂竞争
        // 竞争非常的激烈会升级成重量级锁 10
        Thread.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                               VALUE
      0     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 total
 1
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     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 total
 2
get lock one
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     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 total
 3
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     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 total
 4
get lock two
java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     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 total
 5