sleep,wait,await,park的区别,看这一篇就够了

引子

大家知道,我最近在招人,今天遇到个同学,他的源码看过一些,然后我就开始了AQS连环问。

我:说说AQS的大致流程?

他:AQS包含一个状态变量,一个同步队列……balabala……互斥锁balabala,共享锁balabala……

我:AQS中除了同步队列,还有什么队列?

他:还有个Condition,Condition中有个条件队列……

我:条件队列和同步队列有什么区别?

他:条件队列balabala,然后调用LockSupport.park()进入休眠,等待被唤醒,……,balabala

咦,这时我灵感突发:LockSupport.park()和Thread.sleep()有什么区别?

他:Thread.sleep()不会释放锁资源,……,balabala

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

他:会吧。(估计和Object.wait()搞混淆了)

我:会吗?会吗?会吗?

他(羞涩地低下了头):彤哥,不知道,你的文章里没写。(这段我瞎写的哈^^)

OK,今天我们就来看看LockSupport.park()到底会不会释放锁资源。

Thread.sleep()和Object.wait()的区别

首先,我们先来看看Thread.sleep()和Object.wait()的区别,这是一个烂大街的题目了,大家应该都能说上来两点。

(1)Thread.sleep()不会释放占有的锁,Object.wait()会释放占有的锁;

(2)Thread.sleep()必须传入时间,Object.wait()可传可不传,不传表示一直阻塞下去;

(3)Thread.sleep()到时间了会自动唤醒,然后继续执行;

(4)Object.wait()不带时间的,需要另一个线程使用Object.notify()唤醒;

(5)Object.wait()带时间的,假如没有被notify,到时间了会自动唤醒,这时又分好两种情况,一是立即获取到了锁,线程自然会继续执行;二是没有立即获取锁,线程进入同步队列等待获取锁;

其实,他们俩最大的区别就是Thread.sleep()不会释放锁资源,Object.wait()会释放锁资源。

Thread.sleep()和Condition.await()的区别

我们再来看看Thread.sleep()和Condition.await()的区别。

其实,这个题目和上面的题目比较类似,因为本来Object.wait()和Condition.await()的原理就比较类似,可以参考之前彤哥写的《死磕 java线程系列之线程的生命周期》之篇文章。

这个题目的回答思路跟Object.wait()是基本一致的,不同的是Condition.await()底层是调用LockSupport.park()来实现阻塞当前线程的。

实际上,它在阻塞当前线程之前还干了两件事,一是把当前线程添加到条件队列中,二是“完全”释放锁,也就是让state状态变量变为0,然后才是调用LockSupport.park()阻塞当前线程,可以参考之前彤哥写的《死磕 java同步系列之ReentrantLock源码解析(二)——条件锁》这篇文章。

看到这里,今天开篇提的那个问题是不是就有答案了呢【本文由公从号“彤哥读源码”原创】?

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

LockSupport.park()还有几个兄弟方法——parkNanos()、parkUtil()等,我们这里说的park()方法统称这一类方法。

(1)从功能上来说,Thread.sleep()和LockSupport.park()方法类似,都是阻塞当前线程的执行,且都不会释放当前线程占有的锁资源

(2)Thread.sleep()没法从外部唤醒,只能自己醒过来;

(3)LockSupport.park()方法可以被另一个线程调用LockSupport.unpark()方法唤醒;

(4)Thread.sleep()方法声明上抛出了InterruptedException中断异常,所以调用者需要捕获这个异常或者再抛出;

(5)LockSupport.park()方法不需要捕获中断异常;

(6)Thread.sleep()本身就是一个native方法;

(7)LockSupport.park()底层是调用的Unsafe的native方法;

Object.wait()和LockSupport.park()的区别

二者都会阻塞当前线程的运行,他们有什么区别呢?经过上面的分析相信你一定很清楚了,真的吗?往下看!

(1)Object.wait()方法需要在synchronized块中执行;

(2)LockSupport.park()可以在任意地方执行;

(3)Object.wait()方法声明抛出了中断异常,调用者需要捕获或者再抛出;

(4)LockSupport.park()不需要捕获中断异常【本文由公从号“彤哥读源码”原创】;

(5)Object.wait()不带超时的,需要另一个线程执行notify()来唤醒,但不一定继续执行后续内容;

(6)LockSupport.park()不带超时的,需要另一个线程执行unpark()来唤醒,一定会继续执行后续内容;

(7)如果在wait()之前执行了notify()会怎样?抛出IllegalMonitorStateException异常

(8)如果在park()之前执行了unpark()会怎样?线程不会被阻塞,直接跳过park(),继续执行后续内容;

最后两点是不是没想到?!

其实,在《死磕 java线程系列之自己动手写一个线程池(续)》这篇文章里代码注释里稍微提到过unpark()这个方法,它先执行,则后续的park()方法将不再起作用。

park()/unpark()底层的原理是“二元信号量”,你可以把它相像成只有一个许可证的Semaphore,只不过这个信号量在重复执行unpark()的时候也不会再增加许可证,最多只有一个许可证。

关于信号量的内容,可以参考《死磕 java同步系列之Semaphore源码解析》这篇文章。

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

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

彩蛋

好了,上面我们交叉对比了Thread.sleep()、Object.wait()、Condition.await()、LockSupport.park()的区别。

让我们用一张思维导图结束今天的内容。

park_thread

 

<think>好的,用户想了解除了Thread.sleep()之外,线程调用睡眠、等待或阻塞的接口有哪些。我需要先回忆Java中线程相关的API,然后整理出不同的方法。 首先,Thread.sleep()是让线程进入睡眠状态,但还有其他方法。比如Object类的wait()方法,可以让线程等待,直到被notify()或notifyAll()唤醒。不过wait()需要在同步块中使用,并且会释放锁。 接着是Lock和Condition接口。使用Lock的newCondition()可以创建Condition对象,然后await()方法会让线程等待,类似于wait(),但需要配合Lock使用。还有await(time, unit)这种带超时的方法。 然后想到join()方法,当一个线程调用另一个线程的join()时,当前线程会阻塞,直到目标线程执行完毕。这个可以用来协调线程的执行顺序。 还有阻塞队列,比如BlockingQueue。它的put()和take()方法在队列满或空时会阻塞线程,直到条件满足。比如ArrayBlockingQueue或LinkedBlockingQueue这些实现类。 另外,Future的get()方法在调用时会阻塞,直到任务完成。如果使用ExecutorService提交任务,获取Future对象后调用get(),线程会等待结果返回或者超时。 信号量Semaphore的acquire()方法也会阻塞,当没有可用许可时,线程会等待,直到其他线程释放许可。同样,CountDownLatch的await()会让线程等待,直到计数器减到零。 CyclicBarrier的await()方法会让线程等待,直到所有线程都到达屏障点。这用于多线程同步。 可能还有其他的,比如Socket的I/O操作,比如InputStream.read()在没有数据时会阻塞,但属于I/O阻塞,不是显式的线程控制方法。用户可能更关注显式的线程控制API。 需要确认这些方法的正确性,比如LockSupport的park()和unpark(),这是底层的线程阻塞和唤醒方法,但可能用户不太常用到,不过也应该提到。 总结下来,主要的接口和方法包括: 1. Object.wait() 2. Condition.await() 3. Thread.join() 4. BlockingQueue的put/take 5. Future.get() 6. Semaphore.acquire() 7. CountDownLatch.await() 8. CyclicBarrier.await() 9. LockSupport.park() 需要将这些分类整理,说明每个的使用场景和注意事项,比如是否需要同步块,是否会释放锁等。确保用户能理解不同方法之间的区别和适用情况。</think>在Java中,除了`Thread.sleep()`之外,线程的睡眠、等待或阻塞操作可以通过以下接口实现: --- ### 1. **Object.wait()** - **作用**:使线程进入等待状态,需通过`notify()`或`notifyAll()`唤醒。 - **特点**: - 必须在同步代码块(`synchronized`块)中调用。 - 调用后会释放对象锁。 - **示例**: ```java synchronized (lock) { lock.wait(); // 无限等待 lock.wait(1000); // 最多等待1秒 } ``` --- ### 2. **Condition.await()** - **作用**:与显式锁(`Lock`接口)配合使用,提供更灵活的线程等待。 - **特点**: - 需通过`Lock.newCondition()`创建`Condition`对象。 - 可设置超时时间或响应中断。 - **示例**: ```java Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); lock.lock(); try { condition.await(500, TimeUnit.MILLISECONDS); // 等待500ms } finally { lock.unlock(); } ``` --- ### 3. **Thread.join()** - **作用**:阻塞当前线程,直到目标线程执行完毕。 - **示例**: ```java Thread worker = new Thread(() -> { /* 任务 */ }); worker.start(); worker.join(); // 当前线程等待worker结束 ``` --- ### 4. **BlockingQueue的阻塞操作** - **作用**:通过阻塞队列实现线程间通信。 - **常用方法**: - `put()`:队列满时阻塞,直到有空位。 - `take()`:队列空时阻塞,直到有元素。 - **示例**: ```java BlockingQueue<String> queue = new LinkedBlockingQueue<>(10); queue.put("data"); // 队列满时阻塞 String data = queue.take(); // 队列空时阻塞 ``` --- ### 5. **Future.get()** - **作用**:获取异步任务结果时阻塞,直到任务完成或超时。 - **示例**: ```java ExecutorService executor = Executors.newSingleThreadExecutor(); Future<String> future = executor.submit(() -> "result"); String result = future.get(2, TimeUnit.SECONDS); // 最多等待2秒 ``` --- ### 6. **信号量(Semaphore)** - **作用**:控制资源访问的并发数。 - **方法**:`acquire()`获取许可(无许可时阻塞),`release()`释放许可。 - **示例**: ```java Semaphore semaphore = new Semaphore(3); // 允许3个线程并发 semaphore.acquire(); // 无许可时阻塞 // 访问资源... semaphore.release(); ``` --- ### 7. **CountDownLatch** - **作用**:等待多个线程完成操作。 - **方法**:`await()`阻塞,直到计数器归零。 - **示例**: ```java CountDownLatch latch = new CountDownLatch(3); // 多个线程调用 latch.countDown() latch.await(); // 阻塞直到计数器为0 ``` --- ### 8. **CyclicBarrier** - **作用**:多个线程相互等待,到达屏障后继续执行。 - **方法**:`await()`阻塞,直到所有线程到达屏障。 - **示例**: ```java CyclicBarrier barrier = new CyclicBarrier(3); // 每个线程调用 barrier.await() ``` --- ### 9. **LockSupport.park()** - **作用**:底层线程阻塞工具,通过`LockSupport.unpark()`唤醒。 - **特点**:无需锁,可直接阻塞指定线程。 - **示例**: ```java Thread thread = new Thread(() -> { LockSupport.park(); // 阻塞当前线程 }); thread.start(); LockSupport.unpark(thread); // 唤醒线程 ``` --- ### **总结** - **睡眠**:`Thread.sleep()`(固定时间)、`LockSupport.parkNanos()`(更底层)。 - **等待**:`Object.wait()`、`Condition.await()`(需锁和唤醒机制)。 - **阻塞**:`join()`、`Future.get()`、阻塞队列、同步工具类(如`Semaphore`、`CountDownLatch`)。 选择具体方法时需结合场景(如是否需要锁、超时、线程协作方式等)。
评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值