使用LockSupport实现线程交替打印1-100

简介

LockSupport是JDK底层的基于sun.misc.Unsafe来实现的类，用来创建锁和其他同步工具类的基本线程阻塞原语，在AQS中，就是通过调用LockSupport.park()和LockSupport.unpark()来实现线程的阻塞和唤醒的，不清楚的可以先了解一下AQS基本概况。每一个使用LockSupport的线程都会与一个许可关联，如果许可证在线程中可用，则调用park()将会立即返回，否则可能堵塞；若许可证不可用，则调用unpark()将其转为可用状态。调用park()的次数要少于等于调用unpark()的次数，否则将会导致许可不可用引起阻塞。

LockSupport方法介绍

LockSupport提供的方法不多，且都是类方法，来看下：

• 阻塞线程
  1. park()：阻塞当前线程，需要在线程内调用，如果调用unpark()或者将线程中断，则从park()方法中返回
  2. park(Object blocker)：功能与park()相同，入参是一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查
  3. parkNanos(long nanos)：阻塞当前线程，阻塞时长不超过nanos纳秒，超时自动返回
  4. parkNanos(Object blocker, long nanos)：功能同parkNanos(long nanos)，在其基础上增加了Object对象，等同于是park(Object blocker)+parkNanos(long nanos)的组合
  5. parkUtil(long deadline)：阻塞当前线程，直到deadline后自动返回
  6. parkUtil(Object blocker, long deadline)：：等同于park(Object blocker)+parkUtil(long deadline)的组合
• 唤醒线程
  1. unpar(Thread thread)：唤醒处于阻塞状态的指定线程

以上就是LockSupport的主要方法，每一种park方法都提供了一个Object对象的入参，目的是为了方便进行问题排查，那我们来看下是怎么方便的

1. park()的线程栈

   

2. park(Object blocker)的线程栈

   

使用Object入参的方法之后，线程栈中出现了parking to wait for提示，告诉我们因为哪个对象发生的阻塞，方便我们查找阻塞源头。

例子1

1. 使用两个线程交替打印1-100

   import java.util.concurrent.atomic.AtomicInteger;
   import java.util.concurrent.locks.LockSupport;
   
   public class PrintNumTest {
   
       static AtomicInteger num = new AtomicInteger(1);
   
       public static void main(String[] args) throws InterruptedException {
   
           Print p1 = new Print();
           Print p2 = new Print();
           Thread t1 = new Thread(p1);
           Thread t2 = new Thread(p2);
           t1.setName("thread-cc-1");
           t2.setName("thread-cc-2");
           p1.setT(t2);
           p2.setT(t1);
           t1.start();
           t2.start();
         	// 唤醒线程t1打印奇数，线程1打印奇数，线程2打印偶数
           LockSupport.unpark(t1);
         	// 唤醒线程t2打印奇数，线程1打印偶数，线程2打印奇数
         	// LockSupport.unpark(t1);
       }
   
       static class Print implements Runnable {
           private volatile Thread t;
   
           @Override
           public void run() {
               while (true) {
                 	// 进入之后立即阻塞
                   LockSupport.park();
                   if (num.get() > 100) {
                       LockSupport.unpark(t);
                       return;
                   }
                   System.out.println(Thread.currentThread().getName() + " : " + num.getAndIncrement());
                 	// 奇数唤醒偶数线程，偶数唤醒奇数线程
                   LockSupport.unpark(t);
               }
           }
   
           public void setT(Thread t) {
               this.t = t;
           }
       }
   }
   

   线程使用死循环来保持运行状态，然后使用return来终止运行，进入循环之后立即调用LockSupport.park()阻塞当前线程，在调用线程的start()方法之后两个线程都堵塞在run()方法开始位置，在线程1中打开线程2的许可证，在线程2中打开线程1的许可证，达到交替执行的目的。此时线程都堵塞了，那么我们就可以在主线程中控制先打开哪一个线程的许可证了，如果想让线程1打印奇数，线程2打印偶数，就先把线程1阻塞的许可证打开，让线程1先执行；如果想让线程1打印偶数，线程2打印奇数，就先把线程2阻塞的许可证打开，让线程2先执行。

   • t1打印奇数，t2打印偶数
   

   • t1打印偶数，t2打印奇数

     

2. 使用三个线程交替打印1-100

   import java.util.concurrent.atomic.AtomicInteger;
   import java.util.concurrent.locks.LockSupport;
   
   public class PrintNumTest {
   
       static AtomicInteger num = new AtomicInteger(1);
   
       public static void main(String[] args) throws InterruptedException {
   
           Print p1 = new Print();
           Print p2 = new Print();
           Print p3 = new Print();
           Thread t1 = new Thread(p1);
           Thread t2 = new Thread(p2);
           Thread t3 = new Thread(p3);
           t1.setName("thread-cc-1");
           t2.setName("thread-cc-2");
           t3.setName("thread-cc-3");
           p1.setT(t2);
           p2.setT(t3);
           p3.setT(t1);
           t1.start();
           t2.start();
           t3.start();
           LockSupport.unpark(t1);
       }
   
       static class Print implements Runnable {
           private volatile Thread t;
   
           @Override
           public void run() {
               while (true) {
                   LockSupport.park();
                   if (num.get() > 100) {
                       LockSupport.unpark(t);
                       return;
                   }
                   System.out.println(Thread.currentThread().getName() + " : " + num.getAndIncrement());
                   LockSupport.unpark(t);
               }
           }
   
           public void setT(Thread t) {
               this.t = t;
           }
       }
   
   }