【高并发】2、多线程中的锁

一、多线程中的锁

在多线程中，锁就是要实现线程对资源的访问控制。从程序的角度来看，锁就是一个对象，这个对象需要完成以下几个事情

• 记录该对象是否被某个线程占用；
• 如果被某个线程占用，还需记录这个线程的 Thread ID；
• 记录其他阻塞、等待拿到这个锁的线程的集合，在当前线程释放锁后，从该集合中取出一个线程唤醒；

1.1 锁的分类

乐观锁 和 悲观锁

乐观锁顾名思义就是一种乐观的思想，即每次拿取数据时认为其他线程不会修改，所以不会上锁，但是在更新时会判断在此期间有没有其他线程更新该数据，采取在写入时先读取当前版本号进行比较，如果版本号相同，则更新，如果不同，则重复读取-比较-写的操作。

乐观锁适用于多读的应用类型，这样可以提高吞吐率。Java 中的乐观锁基本上都是通过 CAS（Compare And Swap 比较并交换）实现。

悲观锁顾名思义就是一种悲观的思想，即每次拿取数据时都会认其他线程会修改，所以在每次读取数据时都会上锁，这样其他线程想要读取该数据时就会 block，直到拿到锁。

悲观锁适用于多写的应用类型，Java 中 synchronized 关键字的实现就是悲观锁，AQS 包下的锁则是先尝试乐观锁去获取锁，获取不到，才会转换为悲观锁，如 RetreenLock。

共享锁 和 排它锁

排它锁又称为独占锁、独享锁，Java 中大部分的锁都是排它锁。

共享锁又被称为读锁，获得共享锁后，可以查看但是不能修改和删除数据，其他线程此时也可以获取到共享锁，也可以查看但是不能修改和删除数据。

Java 中共享锁和排它锁的典型是读写锁 ReentrantReadWriteLock，其中读锁是共享锁，写锁是独享锁，两个锁不会同时出现，即要么有一个或多个线程同时持有读锁，要么只有一个线程持有写锁。

公平锁 和 非公平锁

公平锁是指按照线程请求顺序来分配锁。

非公平是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程优先于先申请的线程获得锁，也有可能造成优先级反转或线程饥饿（即每次释放就会被插队抢锁，从而导致某个线程在很长一段时间抢不到锁，始终无法执行）。

Java 中默认的都是非公平锁，在线程启动后会尝试插队去抢锁，如果没有抢到，则再排队。这样的设计主要是为了 提高效率，避免线程唤醒时带来的空档期。

自旋锁

自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样能有效的减少线程上下文切换的消耗，但是会消耗 CPU。

如果该线程一直获取不到锁，将导致一直占用 CPU 自旋，因此需要设定自旋等待的最大时间。在 JDK 1.6 引入了适应性自旋锁，即自旋等待的最大时间由前一次在同一个锁上的自旋时间以及锁持有者的状态来决定，通过 -XX:+UseSpinning 开启，-XX:PreBlockSpin=n 设置自旋的次数；在 JDK 1.7 后，去掉了该参数，由 JVM 控制。

可重入锁

可重入锁又叫递归锁，是指同一个线程在外层方法获得锁的时候，在进入其内部方法会自动获取该锁。

Java 中 Synchronized 和 ReetrantLock 都是可重入锁。可重入锁可以有效避免死锁问题。

死锁

当两个（或更多）线程（或进程）互相持有对方所需的资源，又不主动释放，导致所有线程（或进程）无法继续执行，导致程序陷入无尽的阻塞，这就是死锁，如下图所示：

死锁

产生死锁的条件：

• 互斥条件：每个资源只能被一个线程（或进程）使用，其他线程（或进程）要使用该资源，需要等待该资源被释放；
• 请求与保持条件：一个线程因请求资源而阻塞时，则需要对已获得的资源保持不放；
• 不剥夺条件：线程已获得的资源，在未使用完之前，不会被强行剥夺；
• 循环等待条件：若干线程之间形成一种头尾相接的循环等待资源关系；

必然死锁的代码：

public static void main(String[] args) {

  Object A = new Object();
  Object B = new Object();
  
  new Thread(() -> {
      synchronized(A) {
        try {
            TimeUnit.SECONDS.sleep(1);
            synchronized (B) {
                System.out.println(Thread.currentThread().getName() + "获取到了两把锁");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      }
  }, "A").start();
  
  new Thread(() -> {
      synchronized(B) {
        try {
            TimeUnit.SECONDS.sleep(1);
            synchronized (A) {
                System.out.println(Thread.currentThread().getName() + "获取到了两把锁");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      }
  }, "B").start();
}