三种让线程等待和唤醒的方法

闲不住的码
236 阅读6分钟

方法一：使用Object中的wait()方法让线程等待，使用Object的notify()方法唤醒线程，结合synchronized；

方法二：使用JUC包中的Condition的await()方法让线程等待，使用signal（）方法唤醒线程；

方法三：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程；

用具体实例演示三种方法

方法一 使用wait()和notify()：

public class ObjectWait {
​
    public static void main(String[] args) {
        Object o = new Object();
​
​
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
​
                System.out.println("线程A被o.wait()阻塞前");
                synchronized(o){
                    try {
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
​
                }
                System.out.println("线程A被线程B o.notify()唤醒");
​
            }
        },"A");
​
        t.start();
​
​
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
​
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程B唤醒线程A");
                synchronized (o){
                    o.notify();
                }
            }
        },"B").start();
    }
}
​

结果：

线程A被o.wait()阻塞前

线程B唤醒线程A

线程A被线程B o.notify()唤醒

我们通过o.wait()将线程A阻塞，再通过线程B中运行o.notify()方法将线程A唤醒. 注意：

1、wait和notify都需要在同步块或者同步方法里，也就是要使用到synchronized,将资源类锁住，且必须成对出现。

2、使用时必须先wait 在notify，否则wait不会被唤醒的情况，从而导致线程一直阻塞。

方法二： Lock .condition

public class ConditionAwait {
​
    public static void main(String[] args) {
​
        Lock lock = new ReentrantLock(); 
        Condition condition = lock.newCondition(); //创建condition 对象
​
        new Thread(new Runnable() {
            @Override
            public void run() {
​
                System.out.println("线程A被condition.await()阻塞前");
​
                try {
                    lock.lock();
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
                System.out.println("线程A被线程B condition.signal唤醒");
            }
        }, "A").start();
​
​
        new Thread(new Runnable() {
            @Override
            public void run() {
​
​
​
                try {
                    lock.lock();
​
                    System.out.println("线程B中使用condition.signal()唤醒线程A");
                    condition.signal();
                }catch (Exception e){
​
​
                }finally {
                    lock.unlock();
                }
​
            }
        }, "B").start();
​
    }
}
​

结果： 线程A被condition.await()阻塞前 线程B中使用condition.signal()唤醒线程A 线程A被线程B condition.signal)唤醒

注意：

1 、Condition中的线程等待和唤醒一定要先获得锁。 2、一定要先await,再signal,不能反了

方法三，使用LockSupport

public class LockSupportDemo {
​
    public static void main(String[] args) {
​
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
​
                System.out.println("线程A被LockSupport.park()阻塞");
                LockSupport.park(); //阻塞
​
                System.out.println("线程A被线程B LockSupport.unpark()唤醒");
​
            }
        },"A");
​
        t.start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程B唤醒线程A");
                // 唤醒指定线程t，也就是A
                LockSupport.unpark(t); //唤醒
            }
        },"B").start();
    }
}

结果： 线程A被LockSupport.park()阻塞 线程B唤醒线程A 线程A被线程B LockSupport.unpark()唤醒

注意：

从上面可以看出使用LockSupport 进行线程阻塞和唤醒可以在线程的任意地方执行，并且可以通过unpark(thread)唤醒指定的线程。作为工具类LockSupport的使用，也降低了代码的耦合性。

总结

方法特点缺点
wait/notifywait和notify都需要在同步块或者同步方法里，也就是要使用到synchronized,将资源类锁住，且必须成对出现。 2、使用时必须先wait 在notify，否则wait不会被唤醒的情况，从而导致线程一直阻塞。需要借助synchronized
condition需要结合lock 和unlock ,可以精准唤醒指定线程它的底层其实还是使用的LockSupport
LockSupport使用park 和unpark唤醒指定线程 ，不管是先执行 unpark 还是park，只要是成对出现线程都将被释放多次调用unpark也只能释放一次

LockSupport 是什么？

LockSupport是用来创建锁和其他同步工具类的基本线程阻塞原语。 java锁和同步器框架的核心 AQS: AbstractQueuedSynchronizer，就是通过调用 LockSupport .park()和 LockSupport .unpark()实现线程的阻塞和唤醒 的。 LockSupport 很类似于二元信号量(只有1个许可证可供使用)，如果这个许可还没有被占用，当前线程获取许可并继 续 执行；如果许可已经被占用，当前线 程阻塞，等待获取许可。

更深入的理解

Thread.sleep()和Object.wait()的区别 Thread.sleep()不会释放占有的锁Object.wait()会释放占有的锁；

  • Thread.sleep()必须传入时间，Object.wait()可传可不传，不传表示一直阻塞下去；
  • Thread.sleep()到时间了会自动唤醒，然后继续执行；
  • Object.wait()不带时间的，需要另一个线程使用Object.notify()唤醒；
  • Object.wait()带时间的，假如没有被notify，到时间了会自动唤醒，这时又分好两种情况，一是立即获取到了锁，线程自然会继续执行；二是没有立即获取锁，线程进入同步队列等待获取锁；
  • 其实，他们俩最大的区别就是Thread.sleep()不会释放锁资源，Object.wait()会释放锁资源。

Object.wait()和Condition.await()的区别

  • Object.wait()和Condition.await()的原理是基本一致的，不同的是Condition.await()底层是调用LockSupport.park()来实现阻塞当前线程的。
  • 实际上，它在阻塞当前线程之前还干了两件事，一是把当前线程添加到条件队列中，二是“完全”释放锁，也就是让state状态变量变为0，然后才是调用LockSupport.park()阻塞当前线程。

Thread.sleep()和LockSupport.park()的区别

  • LockSupport.park()还有几个兄弟方法——parkNanos()、parkUtil()等，我们这里说的park()方法统称这一类方法。
  • 从功能上来说，Thread.sleep()和LockSupport.park()方法类似，都是阻塞当前线程的执行，且都不会释放当前线程占有的锁资源；
  • Thread.sleep()没法从外部唤醒，只能自己醒过来；
  • LockSupport.park()方法可以被另一个线程调用LockSupport.unpark()方法唤醒；
  • Thread.sleep()方法声明上抛出了InterruptedException中断异常，所以调用者需要捕获这个异常或者再抛出；
  • LockSupport.park()方法不需要捕获中断异常；
  • Thread.sleep()本身就是一个native方法； LockSupport.park()底层是调用的Unsafe的native方法；

Object.wait()和LockSupport.park()的区别 二者都会阻塞当前线程的运行，他们有什么区别呢?

  • Object.wait()方法需要在synchronized块中执行； LockSupport.park()可以在任意地方执行；
  • Object.wait()方法声明抛出了中断异常，调用者需要捕获或者再抛出
  • LockSupport.park()不需要捕获中断异常；
  • Object.wait()不带超时的，需要另一个线程执行notify()来唤醒，但不一定继续执行后续内容；
  • LockSupport.park()不带超时的，需要另一个线程执行unpark()来唤醒，一定会继续执行后续内容；
  • park()/unpark()底层的原理是“二元信号量”，你可以把它相像成只有一个许可证的Semaphore，只不过这个信号量在重复执行unpark()的时候也不会再增加许可证，最多只有一个许可证。

如果在wait()之前执行了notify()会怎样?

  • 如果当前的线程不是此对象锁的所有者，却调用该对象的notify()或wait()方法时抛出IllegalMonitorStateException异常；
  • 如果当前线程是此对象锁的所有者，wait()将一直阻塞，因为后续将没有其它notify()唤醒它。

如果在park()之前执行了unpark()会怎样?

线程不会被阻塞，直接跳过park()，继续执行后续内容

LockSupport.park()会释放锁资源吗?

不会，它只负责阻塞当前线程，释放锁资源实际上是在Condition的await()方法中实现的。

avatar
文章
阅读
粉丝