java并发(6) 深入理解synchronized关键字

synchronized的三种形式

对于普通的同步方法, 锁的是当前的实例对象
对于静态的同步方法, 锁的是当前的类对象
对于同步方法块, 锁的是给定传入的对象(类或实例)

synchronized的实现原理

同步块中的实现

同步块中, JVM的实现是以 monitorenter 和 monitorexit 指令配对实现的.

当进入 monitorenter指令时将尝试获取当前对象的 monitor的持有权,如果被其他线程占用而无法持有,当前线程将被阻塞. monitorenter指令执行结束,则表示当前线程拥有了该对象的monitor持有权.而monitorexit则表示释放monitor的持有权,即释放了锁.

// 源码
    void lockBlock() {
        synchronized (Main.class) {

        }
    }


# 反汇编
  void lockBlock();
    descriptor: ()V
    flags: (0x0000)
    Code:
      stack=2, locals=3, args_size=1
         0: ldc           #2
         2: dup
         3: astore_1
         4: monitorenter        # 进入同步块
         5: aload_1
         6: monitorexit         # 正常退出同步块
         7: goto          15
        10: astore_2
        11: aload_1
        12: monitorexit         # 异常退出同步块
        13: aload_2
        14: athrow
        15: return

同步方法中的实现

静态同步方法和普通同步方法,是通过方法表结构中的访问标识 access_flag设置为 ACC_SYNCHRONIZED来实现的.

当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有monitor，然后再执行方法，最后再方法完成(无论是正常完成还是非正常完成)时释放monitor。

// 源码
    synchronized void lockMethod() {

    }

# 反汇编
  synchronized void lockMethod();
    descriptor: ()V
    flags: (0x0020) ACC_SYNCHRONIZED
    Code:
      stack=0, locals=1, args_size=1
         0: return

synchronized使用注意事项

普通方法与同步方法调用互不关联

当一个线程进入同步方法时，其他线程可以正常访问其他非同步方法

所有同步方法同时只能被一个线程访问

当一个线程执行同步方法时，其他线程不能访问该对象的任何同步方法

同一个锁的同步代码块同一时刻只能被一个线程访问

当同步代码块都是同一个锁时，方法可以被所有线程访问，但同一个锁的 同步代码块同一时刻只能被一个线程访问.

    void lockBlock() {
        // todo... 这里所有的线程都能进入
        synchronized (Main.class) {
            // todo... 同步代码块中,只有持有锁的线程能进入
        }
    }

线程间同时访问同一个锁的多个同步代码的执行顺序不定

线程间同时访问同一个锁多个同步方法的执行顺序不定，即使是使用同一个对象锁，因为同步方法结束后,锁被释放,所有线程都有可能竞争到锁.

class Demo {
    @Synchronized
    fun synchronizedMethod1(name: String) {
        TimeUnit.MILLISECONDS.sleep(100)
        println("$name : synchronizedMethod1")
    }

    @Synchronized
    fun synchronizedMethod2(name: String) {
        TimeUnit.MILLISECONDS.sleep(100)
        println("$name : synchronizedMethod2")
    }
}

fun main(args: Array) {
    val demo = Demo()
    thread {
        demo.synchronizedMethod1(Thread.currentThread().name)
        demo.synchronizedMethod2(Thread.currentThread().name)
    }
    thread {
        demo.synchronizedMethod2(Thread.currentThread().name)
        demo.synchronizedMethod1(Thread.currentThread().name)
    }
}

// ##########
Thread-0 : synchronizedMethod1
Thread-1 : synchronizedMethod1
Thread-1 : synchronizedMethod2
Thread-0 : synchronizedMethod2

不同锁之间访问非阻塞

对于锁类对象和锁实例对象的锁以及不同对象实例的锁,都互不相关的锁，相互之间不会有任何影响

同步块锁基本变量或者字面量时,变量的值改变,锁的对象也会发生改变.

fun method() {
    var lock = 1
    synchronized(lock) {
        // 如果此时 lock的值在外部被修改,如lock=2,值被修改成了2
        // 即使当前同步方法没有执行完,其他等待的线程可以进入,
        // 因为此时锁变成了 2 , 与之前的 1, 已经不是一个锁了
    }
}

synchronized 特点

独占性(互斥锁)

synchronized是属于线程独占类型的锁,一个线程拿到对象的锁后,其他线程试图进入对象锁的临界资源时，将会处于阻塞状态.
如果 A方法中去获取B的锁, B方法中去获取A的锁,会导致A,B相互等待,形成死锁.

可重入性

当一个线程再次请求自己持有对象锁的临界资源时，不需要通过锁竞争,请求将会成功,这种情况属于重入锁.
因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，是允许的

非公平性

公平锁 : 多个线程在等待同一个锁时，必须按照申请锁的时间顺序排队等待.(cpu吞吐量较低)
非公平锁 : 则不保证这点，在锁释放时，任何一个等待锁的线程都有机会获得锁。(cpu吞吐量高,极端情况下,某些等待线程将永远无法获取到锁)

不可中断性

如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁.

等待的线程将不可被中断(interrupt方法也无法生效),只有两种情况下能释放锁.

获取锁的线程执行完了该代码块，然后线程释放对锁的占有
线程执行发生异常，此时JVM会让线程自动释放锁

jvm对synchronized的优化

JDK1.5中，synchronized是性能低效的。因为这是一个重量级操作，它对性能最大的影响是阻塞的是实现，挂起线程和恢复线程的操作都需要转入内核态中完成，这些操作给系统的并发性带来了很大的压力.

到了JDK1.6，发生了变化，对synchronized加入了很多优化措施，有偏向锁,轻量级锁，锁消除，锁升级，等等。导致synchronized的效率大大的提升.

锁的状态总共有四种，无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级.

对象头

synchronized用的锁是存在Java对象头里的。如果对象是数组类型，则虚拟机用3个字宽（Word）存储对象头，如果对象是非数组类型，则用2字宽存储对象头。在32位虚拟机中，1字宽等于4字节，即32bit.

32位对象头.png

在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化。Mark Word可能变
化为存储以下4种数据:

对象头中锁标志.png

偏向锁

在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，因此为了减少同一线程获取锁(会涉及到一些CAS操作,耗时)的代价而引入偏向锁。

偏向锁的核心思想是，如果一个线程获得了锁，那么锁就进入偏向模式，此时Mark Word 的结构也变为偏向锁结构，当这个线程再次请求锁时，无需再做任何同步操作 ，即获取锁的过程，这样就省去了大量有关锁申请的操作，从而也就提供程序的性能。

对于锁竞争比较激烈的场合，偏向锁将失效,这种情况下可能每次申请锁的线程都是不相同的.偏向锁失效后,会膨胀为轻量级锁.

轻量级锁

倘若偏向锁失败，虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段，此时Mark Word 的结构也变为轻量级锁的结构。

线程尝试使用CAS来讲对象头中的 Mark Word 替换为指向锁记录的指针.如果成功,表示当前线程获取到锁,如果失败,则表示其他线程正在竞争锁,当前线程尝试使用自旋来获取锁(空循环50或100次),如果再失败将膨胀值重量级锁.

即自旋+CAS操作来尝试修改锁标志,成功则获取到锁,失败则升级为重量级锁.

锁消除

消除锁是虚拟机另外一种锁的优化，这种优化更彻底，Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译，又称即时编译)，通过对运行上下文的扫描，去除不可能存在共享资源竞争的锁，通过这种方式消除没有必要的锁，可以节省毫无意义的请求锁时间.

synchronized缺点

只能进行互斥操作,不能实现共享锁,在某些场景下效率低.比如对只读数据的操作.
等待同步线程的不可中断.
没有超时获取锁
只能实现非公平锁,无法实现公平锁.

参考

CAS(Compare and Swap))

比较和交换. 需要输入新值和旧值;如果内存中的值与旧值相同,则内存中的值更新为新值,否则不更新.
如果当前状态值等于预期值,则以原子方式将同步状态设置为给定的更新值.
CAS操作具有volatile读和写的语义.

java中主要通过 UnSafe类的compareAndSwap系列方法来实现,UnSafe是系统保护类,不能直接使用,使用时,需要通过反射调用.

cas 将在处理器中添加 LOCK_前缀的指令. 来保证执行的原子性,禁止重排序,和刷新主内存数据.

三个问题 : ABA, 循环开销大, 只保证一个共享变量的原子操作.

引用

java并发编程的艺术
深入理解Java并发之synchronized实现原理
Java 8 并发篇 - 冷静分析 Synchronized（上）