在java.util.concurrent.locks包下,有一个不经常被人关注的类:LockSupport。用于创建锁和其他同步类的基本线程阻塞元语。
总共有如下几个方法:
LockSupport类使用了一种名为Permit(许可)的概念来做到阻塞和唤醒线程的功能,每个线程都有一个许可(Permit),但是与Semaphore不同的是,许可的累加上限是1
。
大概的意思就是:LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。类似于wait和notify,类似于await和signal。
Java中线程等待唤醒机制有很多:
使用Object中的wait()方法让线程等待,使用Object中的notify()方法唤醒线程;
使用JUC包中Condition的await()方法让线程等待,使用signal()方法唤醒线程;
LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。
那么这三种方式有什么区别呢?
在Java中,除了这三种方式可以实现线程的阻塞、唤醒之外,还可以使用Semaphore、CyclicBarrier、CountDownLatch等类进行实现,但是这几种场景不在本文讨论范围之内,感兴趣小伙伴可以自行关注。
java之Semaphore信号量做限流
java的CyclicBarrier使用
java的CountDownLatch使用
以下例子我们可以看出,使用wait()+notify() 需要配合synchronized 关键字:
// 正确使用wait + notify
public static void main(String[] args)
{
Object objectLock = new Object();
new Thread(() -> {
synchronized (objectLock){
System.out.println(Thread.currentThread().getName()+"\t ----come in");
try {
objectLock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");
}
},"t1").start();
//暂停几秒钟线程
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
synchronized (objectLock){
objectLock.notify();
System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
}
},"t2").start();
}
如果不用synchronized 的话,直接抛出了IllegalMonitorStateException:
public static void main(String[] args)
{
Object objectLock = new Object();
new Thread(() -> {
System.out.println(Thread.currentThread().getName()+"\t ----come in");
try {
objectLock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");
},"t1").start();
//暂停几秒钟线程
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
objectLock.notify();
System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
},"t2").start();
}
我们再反过来看看,如果先nofity,再wait会怎么样:
从结果我们也可以看出,先发出nofity信号再wait,wait之前的nofity信号是没有用的,只有wait之后的nofity信号才可以解除wait。
public static void main(String[] args)
{
Object objectLock = new Object();
new Thread(() -> {
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
synchronized (objectLock){
System.out.println(Thread.currentThread().getName()+"\t ----come in");
try {
objectLock.wait(); // 阻塞住
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");
}
},"t1").start();
new Thread(() -> {
synchronized (objectLock){
objectLock.notify();
System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
}
},"t2").start();
}
通过wait和notify实例我们可以看出,要使用这两个方法,必须要配合synchronized同步代码块才能实现,否则会抛出异常;而且必须要先等待后再唤醒,先唤醒后等待的话,是不会生效的。
同样的,使用await()+signal()也需要配合lock()和unlock()方法:
private static void main(String[] args)
{
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
lock.lock();
try
{
System.out.println(Thread.currentThread().getName()+"\t ----come in");
condition.await();
System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
},"t1").start();
//暂停几秒钟线程
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
lock.lock();
try
{
condition.signal();
System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
}finally {
lock.unlock();
}
},"t2").start();
}
如果不使用lock()和unlock()方法,同样也会抛出异常:
而我们调整代码,先signal()后await(),同样也会导致await()阻塞:
public static void main(String[] args)
{
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
lock.lock();
try
{
System.out.println(Thread.currentThread().getName()+"\t ----come in");
condition.await();
System.out.println(Thread.currentThread().getName()+"\t ----被唤醒");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
},"t1").start();
new Thread(() -> {
lock.lock();
try
{
condition.signal();
System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
}finally {
lock.unlock();
}
},"t2").start();
}
通过await和signal实例我们可以看出,要使用这两个方法,也必须要配合lock同步代码块才能实现,否则会抛出异常;而且必须要先等待后再唤醒,先唤醒后等待的话,是不会生效的。
通过下面的实例我们可以看出,使用LockSupport的park和unpark方法,也可以实现线程的阻塞。并且如果先调用unpark的话,会累计一个许可证
(最多累计一个),下次调用park时可以直接使用该许可证。
public static void main(String[] args)
{
Thread t1 = new Thread(() -> {
try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName() + "\t ----come in"+System.currentTimeMillis());
LockSupport.park();
System.out.println(Thread.currentThread().getName() + "\t ----被唤醒"+System.currentTimeMillis());
}, "t1");
t1.start();
//暂停几秒钟线程
//try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
LockSupport.unpark(t1);
// LockSupport.unpark(t1); 多次unpark并不会累计多个许可证,只会累计一个
System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
},"t2").start();
}
通过底层的UNSAFE类,实现的。
最终都是调用的native方法。
public static void park() {
UNSAFE.park(false, 0L);
}
public static void unpark(Thread thread) {
if (thread != null)
UNSAFE.unpark(thread);
}
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSuppot是一个线程阻寨工县类,所有的方法都是静态方法,可以让线程在任意位置阻塞,阻寨之后也有对应的唤醒方法。
LockSupport调用的Unsafe中的native代码。
LockSupport 提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程。
LockSupport和每个使用它的线程都有一个许可(permit)关联。每个线程都有一个相关的permit,permit最多只有一个,重复调用unpark也不会积累凭证。
线程阻寒需要消耗凭证(permit),这个凭证最多只有1个。
当调用park方法时,如果有凭证,则会直接消耗掉这个凭证然后正常退出; 如果无凭证,就必须阻塞等待凭证可用。
而unpark则相反,它会增加一个凭证,但凭证最多只能有1个,累加无效。