使用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()的线程栈

    image-20200425175946604

  2. park(Object blocker)的线程栈

    image-20200425180113595

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

例子1

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    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打印偶数
    image-20200425194737366
    • t1打印偶数,t2打印奇数

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    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;
    }
    }

    }