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

Java 评论

简介

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;
            }
        }

    }

串一串浪人

断舍离