简介
LockSupport是JDK底层的基于sun.misc.Unsafe
来实现的类,用来创建锁和其他同步工具类的基本线程阻塞原语,在AQS中,就是通过调用LockSupport.park()和LockSupport.unpark()来实现线程的阻塞和唤醒的,不清楚的可以先了解一下AQS基本概况。每一个使用LockSupport的线程都会与一个许可关联,如果许可证在线程中可用,则调用park()将会立即返回,否则可能堵塞;若许可证不可用,则调用unpark()将其转为可用状态。调用park()的次数要少于等于调用unpark()的次数,否则将会导致许可不可用引起阻塞。
LockSupport方法介绍
LockSupport提供的方法不多,且都是类方法,来看下:
- 阻塞线程
- park():阻塞当前线程,需要在线程内调用,如果调用unpark()或者将线程中断,则从park()方法中返回
- park(Object blocker):功能与park()相同,入参是一个Object对象,用来记录导致线程阻塞的阻塞对象,方便进行问题排查
- parkNanos(long nanos):阻塞当前线程,阻塞时长不超过nanos纳秒,超时自动返回
- parkNanos(Object blocker, long nanos):功能同parkNanos(long nanos),在其基础上增加了Object对象,等同于是park(Object blocker)+parkNanos(long nanos)的组合
- parkUtil(long deadline):阻塞当前线程,直到deadline后自动返回
- parkUtil(Object blocker, long deadline)::等同于park(Object blocker)+parkUtil(long deadline)的组合
- 唤醒线程
- unpar(Thread thread):唤醒处于阻塞状态的指定线程
以上就是LockSupport的主要方法,每一种park方法都提供了一个Object对象的入参,目的是为了方便进行问题排查,那我们来看下是怎么方便的
-
park()的线程栈
-
park(Object blocker)的线程栈
使用Object入参的方法之后,线程栈中出现了parking to wait for
提示,告诉我们因为哪个对象发生的阻塞,方便我们查找阻塞源头。
例子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
48import 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;
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打印奇数
-
使用三个线程交替打印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
49import 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;
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;
}
}
}