5.1　显式锁

Java内置锁的功能相对单一，不具备一些比较高级的锁功能，比如：

  1. 限时抢锁：在抢锁时设置超时时长，如果超时还未获得锁就放弃，不至于无限等下去。
  2. 可中断抢锁：在抢锁时，外部线程给抢锁线程发一个中断信号，就能唤起等待锁的线程，并终止抢占过程。

  3. 多个等待队列：为锁维持多个等待队列，以便提高锁的效率。比如在生产者-消费者模式实现中，生产者和消费者共用一把锁，该锁上维持两个等待队列，即一个生产者队列和一个消费者队列。

    5.1.1　显式锁Lock接口

    Lock接口的主要抽象方法
    image.png

    5.1.2　可重入锁ReentrantLock

  4. 可重入的含义: 表示该锁能够支持一个线程对资源的重复加锁，也就是说，一个线程可以多次进入同一个锁所同步的临界区代码块。比如，同一线程在外层函数获得锁后，在内层函数能再次获取该锁，甚至多次抢占到同一把锁。

下面是一段对可重入锁进行两次抢占和释放的伪代码，具体如下：

  1. lock.lock();  // 第一次获取锁 
  2. lock.lock();  // 第二次获取锁，重新进入  
  3. try {  
  4.   // 临界区代码块  
  5. } finally {  
  6.  lock.unlock();  // 释放锁 
  7.  lock.unlock();  // 第二次释放锁
  8. }
  1. 独占的含义：在同一时刻只能有一个线程获取到锁，而其他获取锁的线程只能等待，只有拥有锁的线程释放了锁后，其他的线程才能够获取锁。

一个简单地使用ReentrantLock进行同步累加的演示案例如下：

  1. package com.crazymakercircle.demo.lock;
  2.      // 省略import
  3.      public class LockTest
  4.      {
  5.          @org.junit.Test
  6.          public void testReentrantLock()
  7.          {
  8.              // 每个线程的执行轮数
  9.              final int TURNS = 1000;
  10.              // 线程数
  11.              final int THREADS = 10;
  13.              //线程池，用于多线程模拟测试
  14.              ExecutorService pool = Executors.newFixedThreadPool(THREADS);
  16.              //创建一个可重入、独占的锁对象
  17.              Lock lock = new ReentrantLock();
  18.              // 倒数闩
  19.              CountDownLatch countDownLatch = new CountDownLatch(THREADS);
  20.              long start = System.currentTimeMillis();
  22.              //10个线程并发执行
  23.              for (int i = 0; i < THREADS; i++)
  24.              {
  25.                  pool.submit(() ->
  26.                  {
  27.                      try
  28.                      {
  29.                          //累加 1000 次
  30.                          for (int j = 0; j < TURNS; j++)
  31.                          {
  32.                              //传入锁，执行一次累加
  33.                              IncrementData.lockAndFastIncrease(lock);
  34.                          }
  35.                          Print.tco("本线程累加完成");
  36.                      } catch (Exception e)
  37.                      {
  38.                          e.printStackTrace();
  39.                      }
  40.                      //线程执行完成，倒数闩减少一次
  41.                      countDownLatch.countDown();
  43.                  });
  44.              }

出于“分离变与不变”的设计原则，这里将临界区使用锁的代码进行了抽取和封装，形成一个可以复用的独立类——IncrementData累加类，具体代码如下：

  1. package com.crazymakercircle.demo.lock;
  2.      // 省略import
  3.      //封装锁的使用代码
  4.      public class IncrementData
  5.      {
  6.          public static int sum = 0;
  8.          public static void lockAndFastIncrease(Lock lock)
  9.          {
  11.              lock.lock(); //step1：抢占锁
  12.              try
  13.              {
  14.                  //step2：执行临界区代码
  15.                  sum++;
  16.              } finally
  17.              {
  19.                  lock.unlock(); //step3：释放锁
  20.               }
  21.          }
  22.          // 省略其他代码
  23.      }

5.1.3　使用显式锁的模板代码

  1. 使用lock()方法抢锁的模板代码 ```java //创建锁对象，SomeLock为Lock的某个实现类，如ReentrantLock Lock lock = new SomeLock(); lock.lock(); //step1：抢占锁 try {
    1.   //step2：抢锁成功，执行临界区代码
    } finally {
    1.   lock.unlock();  //step3：释放锁
    }
  2. 2. 调用tryLock()方法非阻塞抢锁的模板代码
  4. 调用tryLock()方法非阻塞抢占锁，大致的模板代码如下：
  5. ```java
  6. //创建锁对象，SomeLock为Lock的某个实现类，如ReentrantLock
  7. Lock lock = new SomeLock(); 
  9. if (lock.tryLock()) {  //step1：尝试抢占锁
  11.  try {
  12.     //step2：抢锁成功，执行临界区代码
  13.  } finally {
  14.      lock.unlock();  //step3：释放锁
  15.  }
  16. } 
  17. else
  18. {
  19.  //step4：抢锁失败，执行后备动作
  20. }

  1. 调用tryLock(long time,TimeUnit unit)方法抢锁的模板代码 ```java //创建锁对象，SomeLock为Lock的某个实现类，如ReentrantLock Lock lock = new SomeLock(); //抢锁时阻塞一段时间，如1秒 if (lock.tryLock(1, TimeUnit.SECONDS)) { //step1：限时阻塞抢占

    1.   try {
    2.      //step2：抢锁成功，执行临界区代码
    3.   } finally {
    4.       lock.unlock();  //step3：释放锁
    5.   }

    } else {

    1.   //限时抢锁失败，执行后备操作

    }

  1. <a name="JhvDl"></a>
  2. ## 5.1.4　基于显式锁进行“等待-通知”方式的线程间通信
  3. 与Object对象的wait、notify两类方法相类似，基于Lock显式锁，JUC也为大家提供了一个用于线程间进行“等待-通知”方式通信的接口——java.util.concurrent.locks.Condition
  5. 1. Condition接口的主要方法
  6. ```java
  7. public interface Condition
  8.  {
  9.      //方法1：等待。此方法在功能上与 Object.wait()语义等效
  10.      //使当前线程加入 await() 等待队列中，并释放当前锁
  11.      //当其他线程调用signal()时，等待队列中的某个线程会被唤醒，重新去抢锁
  12.      void await() throws InterruptedException;
  14.      //方法2：通知。此方法在功能上与Object.notify()语义等效
  15.      // 唤醒一个在 await()等待队列中的线程
  16.      void signal();
  18.      //方法3：通知全部。唤醒 await()等待队列中所有的线程
  19.      //此方法与object.notifyAll()语义上等效
  20.      void signalAll();
  22.      //方法4：限时等待。此方法与await()语义等效
  23.      //不同点在于，在指定时间time等待超时后，如果没有被唤醒，线程将中止等待
  24.      //线程等待超时返回false，其他情况返回true
  25.      boolean await(long time, TimeUnit unit) throws InterruptedException;
  26.  }

  1. 显式锁Condition演示案例 ```java package com.crazymakercircle.demo.lock; // 省略import public class ReentrantCommunicationTest {

    1.   // 创建一个显式锁
    2.   static Lock lock = new ReentrantLock();
    3.   // 获取一个显式锁绑定的Condition对象
    4.   static private Condition condition = lock.newCondition();
    6.   // 等待线程的异步目标任务
    7.   static class WaitTarget implements Runnable
    8.   {
    9.       public void run()
    10.       {
    11.           lock.lock(); // ①抢锁
    12.           try
    13.           {
    14.               Print.tcfo("我是等待方");
    15.               condition.await();  // ② 开始等待，并且释放锁
    16.               Print.tco("收到通知，等待方继续执行");
    17.           } catch (InterruptedException e)
    18.           {
    19.               e.printStackTrace();
    20.           } finally
    21.           {
    22.               lock.unlock();//释放锁
    23.           }
    24.       }
    25.   }
    27.   //通知线程的异步目标任务
    28.   static class NotifyTarget implements Runnable
    29.   {
    30.       public void run()
    31.       {
    32.           lock.lock();  //③抢锁
    33.           try
    34.           {
    35.               Print.tcfo("我是通知方");
    36.               condition.signal(); // ④发送通知
    37.               Print.tco("发出通知了，但是线程还没有立马释放锁");
    38.           } finally
    39.           {
    40.               lock.unlock(); //⑤释放锁之后，等待线程才能获得锁
    41.           }
    42.       }
    43.   }
    45.   public static void main(String[] args) throws InterruptedException
    46.   {
    47.       //创建等待线程
    48.       Thread waitThread = new Thread(new WaitTarget(), "WaitThread");
    49.       //启动等待线程
    50.       waitThread.start();
    51.       sleepSeconds(1); //稍等一下
    53.       //创建通知线程
    54.       Thread notifyThread = new Thread(new NotifyTarget(), "NotifyThread");
    55.       //启动通知线程
    56.       notifyThread.start();
    57.   }

    }

  1. <a name="pILQn"></a>
  2. ## 5.1.5　LockSupport
  3. LockSupport是JUC提供的一个线程阻塞与唤醒的工具类，该工具类可以让线程在任意位置阻塞和唤醒，其所有的方法都是静态方法。
  5. 1. LockSupport的常用方法
  6. ```java
  7. // 无限期阻塞当前线程
  8. public static void park(); 
  10. // 唤醒某个被阻塞的线程
  11. public static void unpark(Thread thread); 
  13. // 阻塞当前线程，有超时时间的限制
  14. public static void parkNanos(long nanos);
  16. // 阻塞当前线程，直到某个时间
  17. public static void parkUntil(long deadline); 
  19. // 无限期阻塞当前线程，带blocker对象，用于给诊断工具确定线程受阻塞的原因
  20. public static void park(Object blocker); 
  22. // 限时阻塞当前线程，带blocker对象
  23. public static void parkNanos(Object blocker, long nanos); 
  25. // 获取被阻塞线程的blocker对象，用于分析阻塞的原因
  26. public static Object getBlocker(Thread t);

  1. LockSupport的演示实例 ```java package com.crazymakercircle.demo.lock; // 省略import public class LockSupportDemo {

    1.   public static class ChangeObjectThread extends Thread
    2.   {
    3.       public ChangeObjectThread(String name)
    4.       {
    5.           super(name);
    6.       }
    8.       @Override
    9.       public void run()
    10.       {
    11.           Print.tco("即将进入无限时阻塞");
    12.           //阻塞当前线程
    13.           LockSupport.park();
    14.           if (Thread.currentThread().isInterrupted())
    15.           {
    16.               Print.tco("被中断了，但仍然会继续执行");
    17.           } else
    18.           {
    19.               Print.tco("被重新唤醒了");
    20.           }
    21.       }
    22.   }
    24.   //LockSupport 测试用例
    25.   @org.junit.Test
    26.   public void testLockSupport()
    27.   {
    28.       ChangeObjectThread t1 = new ChangeObjectThread("线程一");
    29.       ChangeObjectThread t2 = new ChangeObjectThread("线程二");
    30.       //启动线程一
    31.       t1.start();
    32.       sleepSeconds(1);
    33.       //启动线程二
    34.       t2.start();
    35.       sleepSeconds(1);
    36.       //中断线程一
    37.       t1.interrupt();
    38.       //唤醒线程二
    39.       LockSupport.unpark(t2);
    40.   }

    }

  2. 3. LockSupport.park()和Thread.sleep()的区别
  3. 3. LockSupport.park()与Object.wait()的区别
  5. 下面的演示代码演示在LockSupport.park()执行之前，通过执行LockSupport.unPark()唤醒一个线程，具体如下：
  6. ```java
  7. package com.crazymakercircle.demo.lock;
  8.      // 省略import
  9.      public class LockSupportDemo
  10.      {
  11.          @org.junit.Test
  12.          public void testLockSupport2()
  13.          {
  14.              Thread t1 = new Thread(() ->
  15.              {
  16.                  try
  17.                  {
  18.                      Thread.sleep(1000);  //使sleep阻塞当前线程，时长为1秒
  19.                  } catch (InterruptedException e)
  20.                  {
  21.                      e.printStackTrace();
  22.                  }
  23.                  Print.tco("即将进入无限时阻塞");
  24.                  //使用LockSupport.park()阻塞当前线程
  25.                  LockSupport.park();
  26.                  Print.tco("被重新唤醒了");
  28.              }, "演示线程"); //通过匿名对象创建一个线程
  30.              t1.start();
  31.              //唤醒一次没有使用 LockSupport.park()阻塞的线程
  32.              LockSupport.unpark(t1);
  33.              //再唤醒一次没有调用 LockSupport.park()阻塞的线程
  34.              LockSupport.unpark(t1);
  35.              sleepSeconds(2);
  36.              //中断线程一
  37.              //第三唤醒调用 LockSupport.park()阻塞的线程
  38.              LockSupport.unpark(t1);
  40.          }
  41.          // 省略其他
  42.      }

5.1.6　显式锁的分类

显式锁有很多种，从不同的角度来看，显式锁大概有以下几种分类：可重入锁和不可重入锁、悲观锁和乐观锁、公平锁和非公平锁、共享锁和独占锁、可中断锁和不可中断锁。

  1. 可重入锁和不可重入锁
  2. 悲观锁和乐观锁
  3. 公平锁和非公平锁
  4. 可中断锁和不可中断锁

  5. 共享锁和独占锁

    5.2　悲观锁和乐观锁

    独占锁其实就是一种悲观锁，Java的synchronized是悲观锁。悲观锁可以确保无论哪个线程持有锁，都能独占式访问临界区。虽然悲观锁的逻辑非常简单，但是存在不少问题。

    5.2.1　悲观锁存在的问题

  6. 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题

  7. 一个线程持有锁后，会导致其他所有抢占此锁的线程挂起。
  8. 如果一个优先级高的线程等待一个优先级低的线程释放锁，就会导致线程的优先级倒置，从而引发性能风险。

5.2.2　通过CAS实现乐观锁

5.2.3　不可重入的自旋锁

作为演示，这里先实现一个简单版本的自旋锁——不可重入的自旋锁，具体的代码如下：

  1. package com.crazymakercircle.demo.lock.custom;
  2.      // 省略import
  3.      public class SpinLock  implements Lock
  4.      {
  5.          /**当前锁的拥有者
  6.           * 使用Thread 作为同步状态
  7.           */
  8.          private AtomicReference<Thread> owner = new AtomicReference<>();
  9.          /**
  10.           * 抢占锁
  11.           */
  12.          @Override
  13.          public void lock()
  14.          {
  15.              Thread t = Thread.currentThread();
  16.              //自旋
  17.              while (owner.compareAndSet(null, t))
  18.              {
  19.                  // DO nothing
  20.                  Thread.yield();//让出当前剩余的CPU时间片
  21.              }
  22.          }
  24.          /**
  25.           * 释放锁
  26.           */
  27.          @Override
  28.          public void unlock()
  29.          {
  30.              Thread t = Thread.currentThread();
  31.              //只有拥有者才能释放锁
  32.              if (t == owner.get())
  33.              {
  34.                  // 设置拥有者为空，这里不需要 compareAndSet操作
  35.                  // 因为已经通过owner做过线程检查
  36.                  owner.set(null);
  37.              }
  38.          }
  39.          // 省略其他代码
  40.      }

5.2.4　可重入的自旋锁

为了实现可重入锁，这里引入一个计数器，用来记录一个线程获取锁的次数。一个简单的可重入的自旋锁的代码大致如下：

  1. package com.crazymakercircle.demo.lock.custom;
  2.      // 省略import
  3.      public class ReentrantSpinLock implements Lock
  4.      {
  5.          /**当前锁的拥有者
  6.           * 使用拥有者 Thread 作为同步状态，而不是使用一个简单的整数作为同步状态
  7.           */
  8.          private  AtomicReference<Thread> owner = new AtomicReference<>();
  9.          /**
  10.           * 记录一个线程重复获取锁的次数
  11.           * 此变量为同一个线程在操作，没有必要加上volatile保障可见性和有序性
  12.           */
  13.           private int count = 0;
  15.          /**
  16.           * 抢占锁
  17.           */
  18.          @Override
  19.          public void lock()
  20.          {
  21.              Thread t = Thread.currentThread();
  22.              // 如果是重入，增加重入次数后返回
  23.              if (t == owner.get())
  24.              {
  25.                  ++count;
  26.                  return;
  27.              }
  28.              //自旋
  29.              while (owner.compareAndSet(null, t))
  30.              {
  31.                  // DO nothing
  32.                  Thread.yield();//让出当前剩余的CPU时间片
  33.              }
  34.          }
  36.          /**
  37.           * 释放锁
  38.           */
  39.          @Override
  40.          public void unlock()
  41.          {
  42.              Thread t = Thread.currentThread();
  43.              //只有拥有者才能释放锁
  44.              if (t == owner.get())
  45.              {
  46.                  if (count > 0)
  47.                  {
  48.                      // 如果重入的次数大于0， 减少重入次数后返回
  49.                      --count;
  50.                  } else
  51.                  {
  52.                      // 设置拥有者为空
  53.                      // 这里不需要 compareAndSet， 因为已经通过owner做过线程检查
  54.                      owner.set(null);
  55.                  }
  56.              }
  57.          }
  58.          // 省略其他代码
  59.      }

自旋锁的问题：
在争用激烈的场景下，如果某个线程持有锁的时间太长，就会导致其他空自旋的线程耗尽CPU资源。另外，如果大量的线程进行空自旋，还可能导致硬件层面的“总线风暴”。

5.2.5　CAS可能导致“总线风暴”

下面是sun.misc.Unsafe类的compareAndSwapInt()方法的源代码：

  1. public final class Unsafe {
  2. //Unsafe中的CAS操作
  3. public final native boolean compareAndSwapInt(
  4.                          Object o,                  //操作对象
  5.                          long offset,               //字段偏移
  6.                          int expected,              //预期值
  7.                          int x);                            //待更新的值
  8. // 省略不相干代码
  9. }

5.2.6　CLH自旋锁

  1. 实现CLH锁的一个学习版本 ```java package com.crazymakercircle.demo.lock.custom; // 省略import public class CLHLock implements Lock {

    1.   /**
    2.    * 当前节点的线程本地变量
    3.    */
    4.   private static ThreadLocal<Node> curNodeLocal = new ThreadLocal();
    5.   /**
    6.    * CLHLock队列的尾部指针，使用AtomicReference，方便进行CAS操作
    7.    */
    8.   private AtomicReference<Node> tail = new AtomicReference<>(null);
    10.   public CLHLock()
    11.   {
    12.       //设置尾部节点
    13.       tail.getAndSet(Node.EMPTY);
    14.   }
    16.   //加锁操作：将节点添加到等待队列的尾部
    17.   @Override
    18.   public void lock()
    19.   {
    20.       Node curNode = new Node(true, null);
    21.       Node preNode = tail.get();
    22.       //CAS自旋：将当前节点插入队列的尾部
    23.       while (!tail.compareAndSet(preNode, curNode))
    24.       {
    25.           preNode = tail.get();
    26.       }
    27.       //设置前驱节点
    28.       curNode.setPrevNode(preNode);
    30.       // 自旋，监听前驱节点的locked变量，直到其值为false
    31.       // 若前驱节点的locked状态为true，则表示前一个线程还在抢占或者占有锁
    32.       while (curNode.getPrevNode().isLocked())
    33.       {
    34.           //让出CPU时间片，提高性能
    35.           Thread.yield();
    36.       }
    37.       // 能执行到这里，说明当前线程获取到了锁
    38.       // Print.tcfo("获取到了锁！！！");
    40.       //将当前节点缓存在线程本地变量中，释放锁会用到
    41.       curNodeLocal.set(curNode);
    42.   }
    44.   //释放锁
    45.   @Override
    46.   public void unlock()
    47.   {
    48.       Node curNode = curNodeLocal.get();
    49.       curNode.setLocked(false);
    50.       curNode.setPrevNode(null);     //help for GC
    51.       curNodeLocal.set(null);                //方便下一次抢锁
    52.   }
    54.   //虚拟等待队列的节点
    55.   @Data
    56.   static class Node
    57.   {
    58.       public Node(boolean locked, Node prevNode)
    59.       {
    60.           this.locked = locked;
    61.           this.prevNode = prevNode;
    62.       }
    64.       // true：当前线程正在抢占锁，或者已经占有锁
    65.       // false：当前线程已经释放锁，下一个线程可以占有锁了
    66.       volatile boolean locked;
    68.       // 前一个节点，需要监听其locked字段
    69.       Node prevNode;
    71.       // 空节点
    72.       public static final Node EMPTY = new Node(false, null);
    73.   }
    74.   // 省略其他代码

    }

  2. 3. CLH锁的原理分析
  3. 3. 举例说明：CLH锁的抢占过程
  4. 3. 举例说明：CLH锁的释放过程
  5. 3. CLH锁的优缺点
  6. <a name="esjQ7"></a>
  7. # 5.3　公平锁与非公平锁
  8. <a name="nhlQE"></a>
  9. ## 5.3.1　非公平锁实战
  10. 使用ReentrantLock锁作为非公平锁的实战用例，具体代码如下：
  11. ```java
  12. package com.crazymakercircle.basic.demo.lock;
  13.      // 省略import
  14.      public class LockTest
  15.      {
  16.            /**
  17.           * 非公平锁测试用例
  18.           */
  19.          @org.junit.Test
  20.          public void testNotFairLock() throws InterruptedException
  21.          {
  22.              //创建可重入锁，默认的非公平锁
  23.              Lock lock = new ReentrantLock(false);
  25.              //创建Runnable可执行实例
  26.              Runnable r = () -> IncrementData.lockAndIncrease(lock);
  28.              //创建4个线程
  29.              Thread[] tArray = new Thread[4];
  30.              for (int i = 0; i < 4; i++)
  31.              {
  32.                  tArray[i] = new Thread(r, "线程" + i);
  33.              }
  34.              //启动4个线程
  35.              for (int i = 0; i < 4; i++)
  36.              {
  37.                  tArray[i].start();
  38.              }
  39.              Thread.sleep(Integer.MAX_VALUE);
  40.          }
  41.          // 省略其他代码
  42. }

5.3.2　公平锁实战

什么是公平锁呢？公平锁是指多个线程按照申请锁的顺序来获取锁，抢锁成功的次序体现为FIFO（先进先出）顺序。虽然ReentrantLock锁默认是非公平锁，但可以通过构造器指定该锁为公平锁，具体的代码如下：

  1. //可重入、公平锁对象
  2. Lock lock = new ReentrantLock(true);

下面是一个简单的公平锁实战案例。此实战案例并没有使用ReentrantLock锁，而是使用前面自定义的CLHLock锁进行演示，具体的实战代码如下：

  1. package com.crazymakercircle.basic.demo.lock;
  2.      // 省略import
  3.      public class LockTest
  4.      {
  5.          /**
  6.           * 公平锁测试用例
  7.           */
  8.          @org.junit.Test
  9.          public void testFairLock() throws InterruptedException
  10.          {
  11.              //创建为公平锁的类型
  12.              Lock lock = new CLHLock();
  14.              //创建Runnable可执行实例
  15.              Runnable r = () -> IncrementData.lockAndIncrease(lock);
  17.              //创建4个线程
  18.              Thread[] tArray = new Thread[4];
  19.              for (int i = 0; i < 4; i++)
  20.              {
  21.                  tArray[i] = new Thread(r, "线程" + i);
  22.              }
  23.              //启动4个线程
  24.              for (int i = 0; i < 4; i++)
  25.              {
  26.                  tArray[i].start();
  27.              }
  28.              Thread.sleep(Integer.MAX_VALUE);
  29.          }
  30. 　　    // 省略其他代码
  31. }

5.4　可中断锁与不可中断锁

可中断锁是指抢占过程可以被中断的锁，JUC的显式锁（如ReentrantLock）是一个可中断锁。不可中断锁是指抢占过程不可以被中断的锁，如Java的synchronized内置锁就是一个不可中断锁。

5.4.1　锁的可中断抢占

  1. lockInterruptibly()
  2. tryLock(long timeout,TimeUnit unit) ```java package com.crazymakercircle.demo.lock; // 省略import public class IncrementData {
    1.   public static int sum = 0;
    2.   //演示方法：可中断抢锁
    3.   public static void lockInterruptiblyAndIncrease(Lock lock)
    4.   {
    5.       Print.synTco(" 开始抢占锁");
    6.       try
    7.       {
    8.           lock.lockInterruptibly();
    9.       } catch (InterruptedException e)
    10.       {
    11.           Print.synTco("抢占被中断，抢锁失败");
    12.           // e.printStackTrace();
    13.           return;
    14.       }
    15.       try
    16.       {
    17.           Print.synTco("抢到了锁，同步执行1秒");
    18.           sleepMilliSeconds(1000);
    19.           sum++;
    20.           if (Thread.currentThread().isInterrupted())
    21.           {
    22.               Print.synTco("同步执行被中断");
    23.           }
    24.       } catch (Exception e)
    25.       {
    26.           e.printStackTrace();
    27.       } finally
    28.       {
    29.           lock.unlock();
    30.       }
    31.   }
    32.   // 省略其他代码
    }
  1. 以上代码的测试用例具体如下：
  2. ```java
  3. package com.crazymakercircle.basic.demo.lock;
  4.      // 省略import
  5.      public class LockTest
  6.      {
  7.          //测试用例：抢锁过程可中断
  8.          @org.junit.Test
  9.          public void testInterruptLock() throws InterruptedException
  10.          {
  11.              //创建可重入锁，默认的非公平锁
  12.              Lock lock = new ReentrantLock();
  14.              //创建Runnable可执行任务实例
  15.              Runnable r = () -> IncrementData.lockInterruptiblyAndIncrease(lock);
  16.              Thread t1 = new Thread(r, "thread-1");  //创建第1条线程
  17.              Thread t2 = new Thread(r, "thread-2");  //创建第2条线程
  20.              t1.start(); //启动第1个线程
  21.              t2.start(); //启动第2个线程
  22.              sleepMilliSeconds(100);
  23.              Print.synTco( "等待100毫秒，中断两个线程");
  25.              t1.interrupt(); //启动第1个线程
  26.              t2.interrupt(); //启动第2个线程
  28.              Thread.sleep(Integer.MAX_VALUE);
  29.          }
  30.          // 省略其他代码
  31.      }

5.4.2　死锁的监测与中断

JDK 8中包含的ThreadMXBean接口提供了多种监视线程的方法，其中包括两个死锁监测的方法，具体如下：

  1. findDeadlockedThreads
  2. findMonitorDeadlockedThreads

ThreadMXBean的实例可以通过JVM管理工厂ManagementFactory去获取，具体的获取代码如下：

  1. //获取ThreadMXBean的实例
  2. public static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
  1. 在这里举一个死锁监测与中断的案例。首先定义一段需要抢占两把锁才能进入的临界区代码，具体如下：
  1. package com.crazymakercircle.demo.lock;
  2.      // 省略import
  3.      public class TwoLockDemo
  4.      {
  5.          //演示代码：使用两把锁，通过可以中断的方式抢锁
  6.          public static void useTowlockInterruptiblyLock(
  7.                                                              Lock lock1, Lock lock2) {
  8.              String lock1Name = 
  9.                      lock1.toString().replace("java.util.concurrent.locks.", "");
  10.              String lock2Name = 
  11.                      lock2.toString().replace("java.util.concurrent.locks.", "");
  13.              Print.synTco(" 开始抢第一把锁, 为：" + lock1Name);
  14.              try
  15.              {
  16.                  lock1.lockInterruptibly();
  17.              } catch (InterruptedException e)
  18.              {
  19.                  Print.synTco(" 被中断，抢第一把锁失败, 为：" + lock1Name);
  20.                  //e.printStackTrace();
  21.                  return;
  22.              }
  24.              try
  25.              {
  26.                  Print.synTco(" 抢到了第一把锁, 为：" + lock1Name);
  27.                  Print.synTco(" 开始抢第二把锁, 为：" + lock2Name);
  28.                  try
  29.                  {
  30.                      lock2.lockInterruptibly();
  31.                  } catch (InterruptedException e)
  32.                  {
  33.                      Print.synTco(" 被中断，抢第二把锁失败,为：" + lock2Name);
  34.                      //e.printStackTrace();
  35.                      return;
  36.                  }
  37.                  try
  38.                  { 
  39. 　　　　　　　　　Print.synTco(" 抢到了第二把锁：" + lock2Name);
  40.                      Print.synTco("do something ");
  41.                      //等待1000ms
  42.                      sleepMilliSeconds(1000);
  43.                  } catch (Exception e)
  44.                  {
  45.                      e.printStackTrace();
  46.                  } finally
  47.                  {
  48.                      lock2.unlock();
  49.                      Print.synTco(" 释放了第二把锁, 为：" + lock2Name);
  50.                  }
  51.              } catch (Exception e)
  52.              {
  53.                  e.printStackTrace();
  54.              } finally
  55.              {
  56.                  lock1.unlock();
  57.                  Print.synTco(" 释放了第一把锁, 锁为：" + lock1Name);
  58.              }
  59.          }

以上代码的测试用例如下：

  1. package com.crazymakercircle.basic.demo.lock;
  2.      // 省略import
  3.      public class LockTest
  4.      {
  5.          //获取ThreadMXBean
  6.          public static ThreadMXBean mbean = ManagementFactory.getThreadMXBean();
  8.          //测试用例：抢占两把锁，造成死锁，然后进行死锁监测和部分中断
  9.          @org.junit.Test
  10.          public void testDeadLock() throws InterruptedException
  11.          {
  12.              //创建可重入锁，默认的非公平锁
  13.              Lock lock1 = new ReentrantLock();
  14.              Lock lock2 = new ReentrantLock();
  16.              //Runnable异步执行目标实例1: 先抢占lock1，再抢占lock2
  17.              Runnable r1 = () -> 
  18.                      TwoLockDemo.useTowlockInterruptiblyLock(lock1, lock2);
  20.              //Runnable异步执行目标实例2: 先抢占lock2，再抢占 lock1
  21.              Runnable r2 = () ->
  22.                      TwoLockDemo.useTowlockInterruptiblyLock(lock2, lock1);
  24.              Thread t1 = new Thread(r1, "thread-1");  //创建第1个线程
  25.              Thread t2 = new Thread(r2, "thread-2");  //创建第2个线程
  26.              t1.start(); //启动第1个线程
  27.              t2.start(); //启动第2个线程
  29.              //等待一段时间再执行死锁监测
  30.              Thread.sleep(2000);
  31.              Print.tcfo("等待2秒，开始死锁监测和处理");
  33.              //获取到所有死锁线程的id
  34.              long[] deadlockedThreads = mbean.findDeadlockedThreads();
  35.              if (deadlockedThreads.length > 0)
  36.              {
  37.                  Print.tcfo("发生了死锁，输出死锁线程的信息");
  38.                  //遍历数组获取所有的死锁线程id
  39.                  for (long pid : deadlockedThreads)
  40.                  {
  41.                      //此方法用于获取不带有堆栈跟踪信息的线程数据
  42.                      //hreadInfo threadInfo = mbean.getThreadInfo(pid);
  44.                      //此方法用于获取带有堆栈跟踪信息的线程数据
  45.                      ThreadInfo threadInfo = mbean.getThreadInfo(
  46.                                      pid, Integer.MAX_VALUE);
  47.             Print.tcfo(threadInfo);
  48.                  }
  49.                  Print.tcfo("中断一个死锁线程，这里是线程：" + t1.getName());
  50.                  t1.interrupt();  //中断一个死锁线程
  51.              }
  52.          }
  53.          // 省略其他代码
  54.      }

5.5　共享锁与独占锁

5.5.1　独占锁

5.5.2　共享锁Semaphore

共享锁使用示例

  1. package com.crazymakercircle.demo.lock;
  2.      // 省略import
  3.      public class SemaphoreTest
  4.      {
  5.          @org.junit.Test
  6.          public void testShareLock() throws InterruptedException
  7.          {
  8.              // 排队总人数（请求总数）
  9.              final int USER_TOTAL = 10;
  10.              // 可同时受理业务的窗口数量（同时并发执行的线程数）
  11.              final int PERMIT_TOTAL = 2;
  12.              // 线程池，用于多线程模拟测试
  13.              final CountDownLatch countDownLatch = 
  14.                                                        new CountDownLatch(USER_TOTAL);
  15.              // 创建信号量，含有两个许可
  16.              final Semaphore semaphore = new Semaphore(PERMIT_TOTAL);
  17.              AtomicInteger index = new AtomicInteger(0);
  18.              // 创建Runnable可执行实例
  19.              Runnable r = () ->
  20.              {
  21.                  try
  22.                  {
  23.                      //阻塞开始获取许可
  24.                      semaphore.acquire(1);
  25.                      //获取了一个许可
  26.                      Print.tco( DateUtil.getNowTime() 
  27.                            + ", 受理处理中...,服务号: " + index.incrementAndGet());
  29.                      //模拟业务操作: 处理排队业务
  30.                      Thread.sleep(1000);
  31.                      //释放一个信号
  32.                      semaphore.release(1);
  33.                  } catch (Exception e)
  34.                  {
  35.                      e.printStackTrace();
  36.                  }
  37.                  countDownLatch.countDown();
  38.              };
  39.              //创建10个线程
  40.              Thread[] tArray = new Thread[USER_TOTAL];
  41.              for (int i = 0; i < USER_TOTAL; i++)
  42.              {
  43.                  tArray[i] = new Thread(r, "线程" + i);
  44.              }
  45.              //启动10个线程
  46.              for (int i = 0; i < USER_TOTAL; i++)
  47.              {
  48.                  tArray[i].start();
  49.              }
  50.              countDownLatch.await();
  51.          }
  52.      }

5.5.3　共享锁CountDownLatch

  1. package com.crazymakercircle.visiable;
  2.      // 省略import
  3.      class Driver
  4.      {
  5.          private static final int N = 100; // 乘客数
  7.          public static void main(String[] args) throws InterruptedException
  9.          {   //step1：创建倒数闩，设置倒数的总数
  10.              CountDownLatch doneSignal = new CountDownLatch(N);
  11.              //取得CPU密集型线程池
  12.              Executor e = ThreadUtil.getCpuIntenseTargetThreadPool();
  14.              for (int i = 1; i <= N; ++i) // 启动报数任务
  15.                  e.execute(new Person(doneSignal, i));
  17.              doneSignal.await(); //step2：等待报数完成，倒数闩计数值为0
  18.               Print.tcfo("人到齐，开车");   }
  20.          static class Person implements Runnable
  21.          {
  22.              private final CountDownLatch doneSignal;
  23.              private final int i;
  25.              Person(CountDownLatch doneSignal, int i)
  26.              {
  27.                  this.doneSignal = doneSignal;
  28.                  this.i = i;
  29.              }
  31.              public void run()
  32.              {
  33.                  try
  34.                  {
  35.                      //报数
  36.                      Print.tcfo("第" + i + "个人已到");
  37.                      doneSignal.countDown();  //step3:倒数闩减少1
  38.                  } catch (Exception ex)
  39.                  {
  40.                  }
  41.              }
  42.          }
  43.      }

5.6　读写锁

JUC包中的读写锁接口为ReadWriteLock，主要有两个方法，具体如下：

  1. public interface ReadWriteLock {
  2.      /**
  3.       * 返回读锁
  4.       */
  5.      Lock readLock();
  7.      /**
  8.       * 返回写锁
  9.       */
  10.      Lock writeLock();
  11.  }

5.6.1　读写锁ReentrantReadWriteLock

接着进行代码演示，读锁是共享锁，写锁是排他锁：

  1. package com.crazymakercircle.demo.lock;
  2.      // 省略import
  3.      public class ReadWriteLockTest
  4.      {
  5.          //创建一个Map，代表共享数据
  6.          final static Map<String, String> MAP = new HashMap<String, String>();
  7.          //创建一个读写锁
  8.          final static ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock();
  9.          //获取读锁
  10.          final static Lock READ_LOCK = LOCK.readLock();
  11.          //获取写锁
  12.          final static Lock WRITE_LOCK = LOCK.writeLock();
  14.          //对共享数据的写操作
  15.          public static Object put(String key, String value)
  16.          {
  17.              WRITE_LOCK.lock();  //抢写锁
  18.              try
  19.              {
  20.                  Print.tco(DateUtil.getNowTime()

5.6.2　锁的升级与降级

锁升级是指读锁升级为写锁，锁降级指的是写锁降级为读锁。在ReentrantReadWriteLock读写锁中，只支持写锁降级为读锁，而不支持读锁升级为写锁。具体的演示代码如下：

  1. package com.crazymakercircle.demo.lock;
  2.      // 省略import
  3.      public class ReadWriteLockTest2
  4.      {
  5.          //创建一个Map，代表共享数据
  6.          final static Map<String, String> MAP = new HashMap<String, String>();
  7.          //创建一个读写锁
  8.          final static ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock();
  9.          //获取读锁
  10.          final static Lock READ_LOCK = LOCK.readLock();
  11.          //获取写锁
  12.          final static Lock WRITE_LOCK = LOCK.writeLock();
  14.          //对共享数据的写操作
  15.          public static Object put(String key, String value)
  16.          {
  17.              WRITE_LOCK.lock();
  18.              try
  19.              {
  20.                  Print.tco(DateUtil.getNowTime() 
  21.                              + " 抢占了WRITE_LOCK，开始执行write操作");
  22.                  Thread.sleep(1000);
  23.                  String put = MAP.put(key, value);
  24.                  Print.tco( "尝试降级写锁为读锁");
  25.                  //写锁降级为读锁（成功）
  26.                  READ_LOCK.lock();
  27.                  Print.tco( "写锁降级为读锁成功");
  28.                  return put;
  29.              } catch (Exception e)
  30.              {
  31.                  e.printStackTrace();
  32.              } finally
  33.              {
  34.                  READ_LOCK.unlock();
  35.                  WRITE_LOCK.unlock();
  36.              }
  37.              return null;
  38.          }
  40.          //对共享数据的读操作
  41.          public static Object get(String key)
  42.          {
  43.              READ_LOCK.lock();
  44.              try
  45.              {
  46.                  Print.tco(DateUtil.getNowTime()
  47.                               + " 抢占了READ_LOCK，开始执行read操作");
  48.                  Thread.sleep(1000);
  49.                  String value = MAP.get(key);
  50.                  Print.tco( "尝试升级读锁为写锁");
  51.                  //读锁升级为写锁(失败)
  52.                  WRITE_LOCK.lock();
  53.                  Print.tco("读锁升级为写锁成功");
  54.                  return value;
  55.              } catch (InterruptedException e)
  56.              {
  57.                  e.printStackTrace();
  58.              } finally
  59.              {
  60.                  WRITE_LOCK.unlock();
  61.                  READ_LOCK.unlock();
  62.              }
  63.              return null;
  64.          }
  66.          public static void main(String[] args)
  67.          {
  68.              //创建Runnable可执行实例
  69.              Runnable writeTarget = () -> put("key", "value");
  70.              Runnable readTarget = () -> get("key");
  71.              //创建1个写线程，并启动
  72.              new Thread(writeTarget, "写线程").start();
  74.              //创建1个读线程
  75.              new Thread(readTarget, "读线程").start();
  76.          }
  77.      }

5.6.3　StampedLock

StampedLock（印戳锁）是对ReentrantReadWriteLock读写锁的一种改进，主要的改进为：在没有写只有读的场景下，StampedLock支持不用加读锁而是直接进行读操作，最大程度提升读的效率，只有在发生过写操作之后，再加读锁才能进行读操作。

  1. 悲观读锁的获取与释放 ```java //获取普通读锁（悲观读锁），返回long类型的印戳值 public long readLock()

//释放普通读锁（悲观读锁），以取锁时的印戳值作为参数 public void unlockRead(long stamp)

  2. 2. 写锁的获取与释放
  3. ```java
  4. //获取写锁，返回long类型的印戳值
  5. public long writeLock()
  7. //释放写锁，以获取写锁时的印戳值作为参数
  8. public void unlockWrite(long stamp)
  1. 乐观读的印戳获取与有效性判断 ```java //获取乐观读，返回long类型的印戳值，返回0表示当前锁处于写锁模式，不能乐观读 public long tryOptimisticRead()

//判断乐观读的印戳值是否有效，以tryOptimisticRead返回的印戳值作为参数 public long tryOptimisticRead(long stamp)

  1. StampedLock的演示案例
  2. ```java
  3. package com.crazymakercircle.demo.lock;
  4.      // 省略import
  5.      public class StampedLockTest
  6.      {
  7.          //创建一个Map，代表共享数据
  8.          final static Map<String, String> MAP = new HashMap<String, String>();
  9.          //创建一个印戳锁
  10.          final static StampedLock STAMPED_LOCK = new StampedLock();
  12.          //对共享数据的写操作
  13.          public static Object put(String key, String value)
  14.          {
  15.              long stamp = STAMPED_LOCK.writeLock();   //尝试获取写锁的印戳
  16.              try
  17.              {
  18.                  Print.tco(getNowTime() + " 抢占了WRITE_LOCK，开始执行write操作");
  19.                  Thread.sleep(1000);
  20.                  String put = MAP.put(key, value);
  21.                  return put;
  22.              } catch (Exception e)
  23.              {
  24.                  e.printStackTrace();
  25.              } finally
  26.              {
  27.                  Print.tco(getNowTime() + " 释放了WRITE_LOCK");
  28.                  STAMPED_LOCK.unlockWrite(stamp); //释放写锁
  29.              }
  30.              return null;
  32.          }
  34.          //对共享数据的悲观读操作
  35.          public static Object pessimisticRead(String key)
  36.          {
  37.              Print.tco(getNowTime() + "LOCK进入过写模式，只能悲观读");
  38.              //进入了写锁模式，只能获取悲观读锁
  39.              long stamp = STAMPED_LOCK.readLock();  //尝试获取读锁的印戳
  40.              try
  41.              {
  42.                 //成功获取到读锁，并重新获取最新的变量值
  43.                  Print.tco(getNowTime() + " 抢占了READ_LOCK");
  44.                  String value = MAP.get(key); 
  45.                  return value;
  46.              } finally
  47.              {
  48.                  Print.tco(getNowTime() + " 释放了READ_LOCK");
  49.                  STAMPED_LOCK.unlockRead(stamp); //释放读锁
  50.              }
  51.          }
  53.          //对共享数据的乐观读操作
  54.          public static Object optimisticRead(String key)
  55.          {
  56.              String value = null;
  57.              //尝试进行乐观读
  58.              long stamp = STAMPED_LOCK.tryOptimisticRead();
  59.              if (0 != stamp)
  60.              {
  61.                  Print.tco(getNowTime() + "乐观读的印戳值，获取成功");
  62.                  sleepSeconds(1); //模拟耗费时间1秒
  63.                  value = MAP.get(key);
  65.              } else  // 0 == stamp 表示当前为写锁模式
  66.              {
  67.                  Print.tco(getNowTime() + "乐观读的印戳值，获取失败");
  68.                  //LOCK已经进入写模式，使用悲观读方法
  69.                  return pessimisticRead(key);
  70.              }
  71.              //乐观读操作已经间隔了一段时间，期间可能发生写入
  72.              //所以，需要验证乐观读的印戳值是否有效，即判断LOCK是否进入过写模式
  73.              if (!STAMPED_LOCK.validate(stamp))
  74.              {
  75.                  //乐观读的印戳值无效，表明写锁被占用过