Lock 相关整理

• 锁是用来控制多个线程访问共享资源的方式。
• Java 程序可以使用 syschronized 关键字实现锁功能，而 Java 5 之后，在并发包中新增了 Lock 接口（以及相关实现类）用来实现锁功能。
  • Lock 提供了与 syschronized 关键字类似的同步功能，只是在使用时需要 显式地获取和释放锁。虽然缺少了 syschronized 关键字的隐式获取释放锁的便捷性（锁获取和释放被固化了，先获取再释放），但却拥有了锁获取与释放的可操作性、可中断的获取锁以及超时获取锁等多种 syschronized 关键字所不具备的同步特性。

1. Lock

• Lock 相关的类和接口主要在 java.util.concurrent.locks 包下。
• 使用 synchronized 不需要用户去手动释放锁，当 synchronized 方法或者 synchronized 代码块执行完之后，系统会自动让线程释放对锁的占用，而 Lock 必须要用户手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
• Lock 是一个接口

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;  // 可以响应中断
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;  // 可以响应中断
    void unlock();
    Condition newCondition();
}

方法	说明
lock()	用来获取锁，如果锁已被其他线程获取，则进行等待。采用 Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。一般来说，使用 Lock 必须在 try…catch… 块中进行，并且将释放锁的操作放在 finally 块中进行，以保证锁一定被被释放，防止死锁的发生。
tryLock()	表示用来尝试获取锁，如果获取成功，则返回 true，如果获取失败（即锁已被其他线程获取），则返回 false。在拿不到锁时不会一直等待，无论如何都会立即返回。
tryLock(long time, TimeUnit unit)	与 tryLock() 方法类似，区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回 false，同时可以响应中断。如果一开始拿到锁或者在等待期间内拿到了锁，则返回 true。
lockInterruptibly()	当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。例如，当两个线程同时通过 lock.lockInterruptibly() 想获取某个锁时，假若此时线程 A 获取到了锁，而线程 B 只有在等待，那么对线程 B 调用threadB.interrupt() 方法能够中断线程 B 的等待过程。
unlock()	释放锁
newCondition()	由当前 Lock 创建一个 Condition 对象用于调用 await、signal、signalAll 等同步方法。

• 当一个线程获取了锁之后，是不会被 interrupt() 方法中断的。因为 interrupt() 方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程。
  • 因此，当通过 lockInterruptibly() 方法获取某个锁时，如果不能获取到，那么只有进行等待的情况下，才可以响应中断。

1.1 synchronized 与 Lock 的区别

类别	synchronized	Lock
存在层次	Java 关键字，在 JVM 层面	类
锁的释放	1.以获取锁的线程执行完同步代码释放锁；2.线程执行发生异常，JVM 会让线程释放锁。	在 finally 中必须释放锁，不然容易造成线程死锁。
锁的获取	假设 A 线程获得锁，B 线程等待。如果 A 线程阻塞，B 线程会一直等待。	尝试获得锁，线程可以不用一直等待。
锁状态	无法判断	可以判断
锁类型	可重入、不可中断、非公平	可重入、可判断、可公平（两者皆可）
性能	少量同步	大量同步

1.2 锁的分类

公平锁和非公平锁

• 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的先后顺序来依次获得锁。
  • 公平锁的好处在于等待锁的线程不会饿死，但是整体效率相对低一些。
  • 非公平锁的好处是整体效率相对高一些，但是有些线程可能会饿死或者说很早就在等待锁，但要等很久才会获得锁。
  • 其中的原因是公平锁是严格按照请求所的顺序来排队获得锁的，而非公平锁时可以抢占的，即如果在某个时刻有线程需要获取锁，而这个时候刚好锁可用，那么这个线程会直接抢占，而这时阻塞在等待队列的线程则不会被唤醒。
• 公平锁可以使用 new ReentrantLock(true) 实现。

上述是简单介绍了公平锁与非公平锁，具体分析可以参考：https://www.cnblogs.com/youngao/p/12547512.html

乐观锁和悲观锁

• 锁从宏观上分类，可以分为悲观锁与乐观锁。
  • 乐观锁
    • Java 中的乐观锁基本都是通过 CAS 操作实现，比较当前值跟传入值是否一样，一样则更新，否则失败。
    • 一种乐观思想，即认为读多写少，遇到并发写的可能性低，每次拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，采取在写时先读出当前版本号，然后加锁操作（比较跟上一次的版本号，如果一样则更新），如果失败则要重复读 - 比较 - 写的操作。

    • Java当中的java.util.concurrent.atomic包下面的原子类就是用乐观锁的思想，用CAS方式实现的。

 

• • 悲观锁
    • 一种悲观思想，即认为写多，遇到并发写的可能性高，每次拿数据的时候都认为别人会修改，每次在读写数据的时候都会上锁，这样别人想读写这个数据就会 block 直到拿到锁。用于多写的场景，保证线程安全和数据安全。
    • Java 中的悲观锁如： synchronized。
    • AQS 框架下的锁则是先尝试 CAS 乐观锁去获取锁，获取不到，才会转换为悲观锁，如
      ReentrantLock。

可重入锁

• 可重入锁，也叫做递归锁，指的是同一线程外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。
  • ReentrantLock 和 synchronized 都是可重入锁。
  • 可重入锁最大的作用是避免死锁。

上面简单的介绍了可重入锁，具体分析参考：https://www.cnblogs.com/youngao/p/12547512.html

读写锁

• 读写锁是一个资源能够被多个读线程访问，或者被一个写线程访问但不能同时存在读线程。
  • Java 当中的读写锁通过 ReentrantReadWriteLock 实现。

互斥锁

• 指一次最多只能有一个线程持有的锁。
  • synchronized 和 Lock 都是互斥锁。

闭锁

• 闭锁是一种同步工具类，可以延迟线程的进度直到其到达终止状态。
  • 闭锁的作用相当于一扇门，在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程能通过，当到达结束状态时，这扇门会打开允许所有的线程通过。
  • 当闭锁到达结束状态后，将不会再改变状态，因此这扇门将永远保持打开状态。
  • 闭锁可以用来确保某些活动指导其他活动都完成后才继续执行。
  • CountDownLatch 就是一种灵活的闭锁实现。