Java中sleep()与wait(),线程让步(yield())的区别

Java线程控制详解
本文详细解析了Java中线程控制的关键方法,如sleep(), wait(), notify(), notifyAll()及yield()和join()的使用场景与区别。通过对比,帮助读者理解这些方法的工作原理及其在多线程编程中的应用。

第一种解释:

功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步锁

还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起

第二种解释:

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间,在时间到达时恢复,也就是说sleep将在接到时间到达事件事恢复线程执行,例如:

try{

System.out.println("I'm going to bed");

Thread.sleep(1000);

System.out.println("I wake up");

}

catch(IntrruptedException e) {

}

wait是Object的方法,也就是说可以对任意一个对象调用wait方法,调用wait方法将会将调用者的线程挂起,直到其他线程调用同一个对象的notify方法才会重新激活调用者,例如:

Thread 1

try{

obj.wait();//suspend thread until obj.notify() is called

}

catch(InterrputedException e) {

}

第三种解释:

这两者的施加者是有本质区别的. 

sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.

而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但这个流程并没有结束,我一直想去煮饭,但还没被允许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处继续执行.

其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题

在java.lang.Thread类中,提供了sleep(),

而java.lang.Object类中提供了wait(), notify()和notifyAll()方法来操作线程

sleep()可以将一个线程睡眠,参数可以指定一个时间。

而wait()可以将一个线程挂起,直到超时或者该线程被唤醒。

 wait有两种形式wait()和wait(milliseconds).

sleep和wait的区别有:

  1,这两个方法来自不同的类分别是Thread和Object

  2,最主要是sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法。

  3,wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在

    任何地方使用

   synchronized(x){

      x.notify()

     //或者wait()

   }

   4,sleep必须捕获异常,而wait,notify和notifyAll不需要捕获异常

三、线程让步(yield方法)
由运行态到就绪态,停止一下后再由就绪态到运行态

暂停当前正在执行的线程对象,并执行其他线程。
意思就是调用yield方法会让当前线程交出CPU权限,让CPU去执行其他的线程。它跟sleep方法类似,同样不会释放锁。
但是yield不能立刻交出CPU,会出现同一个线程一直执行的情况,另外,yield方法只能让拥有相同优先级的线程有获取CPU执行时间的机会。
注意调用yield方法并不会让线程进入阻塞状态,而是让线程重回就绪状态,它只需要等待重新获取CPU执行时间,这一点是和sleep方法不一样的
 

四、join方法

运行态到阻塞态(释放锁),让“主线程”等待“子线程”结束之后才能继续运行

常见面试题,如有3个线程A,B,C,如何保证三个线程的有序性,则可以通过join方法来实现

 

五. 线程优先级:setPriority,随机性,并不能保证线程的执行顺序

 

<think>我们正在讨论Java线程中的yield()方法。根据引用[1]到[5],我们可以总结如下: 1. yield()是Thread类的静态方法,使用native关键字修饰,意味着它的具体实现依赖于操作系统的线程调度机制。 2. yield()的作用是提示线程调度器当前线程愿意让出CPU使用权,但线程调度器可以忽略这个提示。 3. 调用yield()后,当前线程从运行状态变为就绪状态,但不会进入阻塞状态(如sleep()那样)。 4. yield()不能保证其他线程(尤其是相同优先级的线程)一定会获得执行机会,因为当前线程可能立即再次被调度执行。 5. yield()适用于让相同优先级的线程有更多执行机会,但不保证线程调度的公平性。 使用场景: - 需要让相同优先级的线程轮流执行时,可以使用yield()。 - 在自旋锁中,为了避免忙等待过度消耗CPU,可以在循环中加入yield(),让出CPU给其他线程。 注意事项: - yield()不会释放线程已经持有的锁。 - 过度使用yield()可能会降低序性能,因为增加了线程上下文切换。 下面是一个简单的示例,展示yield()的使用: ```java public class YieldExample { public static void main(String[] args) { Runnable task = () -> { for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); Thread.yield(); // 让出CPU } }; Thread t1 = new Thread(task, "Thread-1"); Thread t2 = new Thread(task, "Thread-2"); t1.start(); t2.start(); } } ``` 在这个例子中,两个线程交替执行的可能性增加了,因为每个线程在打印一次后都会调用yield(),给另一个线程执行的机会。但请注意,这并不能严格保证交替执行,因为线程调度器可能会忽略yield()提示。 相关问题: 1. yield()方法sleep()方法有什么区别? 2. 在Java中,如何正确使用yield()方法来实现线程间的协作? 3. yield()方法在自旋锁中是如何应用的?</think>### Java线程中 `Thread.yield()` 方法详解 `Thread.yield()` 是 Java线程中一个重要的线程调度方法,用于优化 CPU 资源分配。以下是其核心作用和使用场景的详细解析: #### 一、方法作用原理 1. **状态转换机制** - 调用 `Thread.yield()` 会使**当前线程从运行状态(RUNNING)转为就绪状态(READY)** [^2][^3] - `sleep()`/`wait()` 不同:**不会释放锁**,也不会进入阻塞状态[^4] - 示例状态转换: ``` 运行中 → yield() → 就绪 → (可能立即) → 再次运行 ``` 2. **调度行为** - 向线程调度器发出提示:**当前线程愿意让出 CPU 使用权**[^1] - 调度器可能(但不保证)选择**相同优先级的其他就绪线程**执行[^3] - 实际效果:**降低当前线程在本次时间片内的执行权重** 3. ** sleep() 的关键区别** | 特性 | `yield()` | `sleep()` | |--------------------|-------------------------------|-------------------------------| | 线程状态 | RUNNABLE(就绪) | TIMED_WAITING(阻塞) | | 锁释放 | 不释放任何锁 | 不释放锁 | | 恢复确定性 | 可能立即恢复执行 | 固定时间后恢复 | | 调度控制强度 | 提示性(可能被忽略) | 强制性 | #### 二、典型使用场景 1. **避免线程饥饿** 在计算密集型任务中插入 `yield()`,防止单个线程长期独占 CPU: ```java public void run() { while (!taskDone) { // 密集计算 heavyCalculation(); // 每轮计算后让出CPU Thread.yield(); } } ``` 2. **自旋锁优化** 在自旋锁等待期间减少 CPU 空转消耗[^3]: ```java while (!lock.tryAcquire()) { // 让出CPU而非忙等待 Thread.yield(); } ``` 3. **优先级平衡** 当高优先级线程需要临时让步时: ```java public class HighPriorityTask implements Runnable { @Override public void run() { processCriticalSection(); Thread.yield(); // 主动让出给同优先级线程 processNonCriticalSection(); } } ``` #### 三、重要注意事项 1. **行为不确定性** - `yield()` **仅是提示**,调度器可能忽略该请求[^2][^3] - 无参数的 `Thread.yield()` 是 `native` 方法,具体实现依赖 JVM 和操作系统[^5] 2. **优先级依赖** - 主要影响**相同优先级的线程**,低优先级线程仍需等待[^3] - 示例优先级关系: ``` 优先级5(运行)→ yield() → 优先级5(就绪) vs 优先级5(其他就绪) 不会直接切换到优先级4的线程 ``` 3. **性能考量** - 过度使用会增加**线程上下文切换开销** - 实测案例:某循环中每 1000 次迭代调用一次 `yield()` 时性能最佳 #### 四、完整示例 ```java public class YieldDemo { public static void main(String[] args) { Runnable task = () -> { for (int i = 1; i <= 3; i++) { System.out.println(Thread.currentThread().getName() + " 执行第 " + i + " 步"); if (i == 2) { System.out.println("-- " + Thread.currentThread().getName() + " 调用 yield() --"); Thread.yield(); // 关键让步点 } } }; Thread t1 = new Thread(task, "高优先级线程"); Thread t2 = new Thread(task, "普通线程"); t1.setPriority(Thread.MAX_PRIORITY); t2.setPriority(Thread.NORM_PRIORITY); t1.start(); t2.start(); } } ``` **可能输出**(实际顺序可能变化): ``` 高优先级线程 执行第 1 步 高优先级线程 执行第 2 步 -- 高优先级线程 调用 yield() -- 普通线程 执行第 1 步 // yield() 后普通线程获得机会 普通线程 执行第 2 步 -- 普通线程 调用 yield() -- 高优先级线程 执行第 3 步 // 高优先级线程继续执行 普通线程 执行第 3 步 ``` #### 五、最佳实践建议 1. **适用场景** ✅ 计算密集型任务的协作式调度 ✅ 自旋锁等待优化 ✅ 测试环境模拟线程竞争 2. **规避场景** ❌ I/O 阻塞操作(让出 CPU 无意义) ❌ 需要精确控制执行顺序的场景 ❌ 低优先级线程需要紧急执行的场景 3. **替代方案** - 需要强同步时:用 `wait()/notify()` 或 `Lock/Condition` - 定时暂停:用 `Thread.sleep(millis)` - 高级调度:用 `ExecutorService` 线程池管理 > 总结:`yield()` 是细粒度优化工具而非同步原语,应**谨慎用于特定性能优化场景**。其非确定性特性要求开发者充分理解线程调度机制[^1][^5]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值