参考：https://blog.csdn.net/qq_43470725/article/details/120457461
1、线程生命周期图解
2、方法：wait(), notify(), notifyAll()等方法介绍：
-
1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
-
2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。
-
3.wait(long timeout)让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。
wait()、notify()方法需要和synchronized一起使用
为什么这三个方法要与synchronized一起使用呢？解释这个问题之前，我们先要了解几个知识点
- 每一个对象都有一个与之对应的监视器
- 每一个监视器里面都有一个该对象的锁以及一个等待队列和一个同步队列
wait()方法的语义有两个，一是释放当前对象锁，另一个是进入阻塞队列，可以看到，这些操作都是与监视器相关的，当然要指定一个监视器才能完成这个操作了
notify()方法也是一样的，用来唤醒一个线程，你要去唤醒，首先你得知道他在哪儿，所以必须先找到该对象，也就是获取该对象的锁，当获取到该对象的锁之后，才能去该对象的对应的等待队列去唤醒一个线程。值得注意的是，只有当执行唤醒工作的线程离开同步块，即释放锁之后，被唤醒线程才能去竞争锁。
因wait()而导致阻塞的线程是放在阻塞队列中的，因竞争失败导致的阻塞是放在同步队列中的，notify()/notifyAll()实质上是把阻塞队列中的线程放到同步队列中去
为了便于理解，你可以把线程想象成一个个列车，对象想象成车站，每一个车站每一次能跑一班车，这样理解起来就比较容易了。
值得提的一点是，synchronized是一个非公平的锁，如果竞争激烈的话，可能导致某些线程一直得不到执行。
3、具体使用：
需求:
实现一个容器，提供两个方法add、size，写两个线程：
线程1，添加10个元素到容器中
线程2，实时监控元素个数，当个数到5个时，线程2给出提示并结束
这个例子使用了synchronized从一个全局唯一对象上拿锁，能充分理解synchronized的作用。
也能充分理解wait()、notify()方法的使用：
package com.example.dtest.threadTest.use;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
/*
- 实现一个容器，提供两个方法add、size，写两个线程：
线程1，添加10个元素到容器中
线程2，实时监控元素个数，当个数到5个时，线程2给出提示并结束
- */
public class WaitAndNotifyTest {
//添加volatile，使t2能够得到通知
volatile List lists = new ArrayList();
public void add(Object o) {
lists.add(o);
}
public int size() {
return lists.size();
}
public static void main(String[] args) {
WaitAndNotifyTest c = new WaitAndNotifyTest();
final Object lock = new Object();
//需要注意先启动t2再启动t1
new Thread(() -> {
synchronized(lock) {
System.out.println("t2 启动");
if(c.size() != 5) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("t2 结束");
//通知t1继续执行
lock.notify();
}
}, "t2").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
new Thread(() -> {
System.out.println("t1 启动");
synchronized(lock) {
for(int i=0; i<10; i++) {
c.add(new Object());
System.out.println("add " + i);
if(c.size() == 5) {
lock.notify();
//释放锁，让t2得以执行
try{
lock.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "t1").start();
}
}
这里可以看到：wait(), notify(), notifyAll()方法都是类（普通对象）级别的方法；这里的对象必须是synchronized锁的对象才可以；
流程分析：
- 一开始：t2只要c（容器）的容量不等于5，那他就是在锁对象外面等待的线程：lock.wait();
- t1执行到容器数量是5个的时候，唤醒所对象外面等待的单个线程lock.notify();
- notify()方法是不会是释放锁的，所以在notify()以后，又紧接着调用了wait()方法阻塞了t1线程，wait()方法会释放锁.实现了t2线程的实时监控，t2线程执行结束，打印出相应提示
- 然后t1会执行输出后唤醒t2 lock.notify();，然后继续执行，t1这个线程任务完成就自动死亡了，将锁释放
sleep() 和 yield()方法
是在Thread类里面，属于静态方法
这两个方法都定义在Thread.java中
sleep()的作用是让当前线程休眠（正在执行的线程主动让出cpu，然后cpu就可以去执行其他任务），即当前线程会从“运行状态”进入到“休眠（阻塞）状态”。sleep()会指定休眠时间，线程休眠的时候会大于或者等于该休眠时间，当时间过后该线程重新被会形式，他会由“阻塞状态”编程“就绪状态”，从而等待cpu的调度执行，注意：sleep方法只是让出了cpu的执行权，并不会释放同步资源锁。
yield()的作用是让步，它能够让当前线程从“运行状态”进入到“就绪状态”，从而让其他等待线程获取执行权，但是不能保证在当前线程调用yield()之后，其他线程就一定能获得执行权，也有可能是当前线程又回到“运行状态”继续运行，注意：这里我将上面的“具有相同优先级”的线程直接改为了线程，很多资料都写的是让具有相同优先级的线程开始竞争，但其实不是这样的，优先级低的线程在拿到cpu执行权后也是可以执行，只不过优先级高的线程拿到cpu执行权的概率比较大而已，并不是一定能拿到。
举个例子：一帮朋友在排队上公交车，轮到Yield的时候，他突然说：我不想先上去了，咱们大家来竞赛上公交车。然后所有人就一块冲向公交车，
有可能是其他人先上车了，也有可能是Yield先上车了。
但是线程是有优先级的，优先级越高的人，就一定能第一个上车吗？这是不一定的，优先级高的人仅仅只是第一个上车的概率大了一点而已，
最终第一个上车的，也有可能是优先级最低的人。并且所谓的优先级执行，是在大量执行次数中才能体现出来的。
不同点：
Thread类的方法：sleep(),yield()
Object的方法：wait()和notify()、notifyAll()
suspend()和 resume()方法
是Thread类的对象方法，要new后才能使用！！
两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会自动恢复，必须其对应的resume()被调用，才能使得线程重新进入可执行状态。典型地，suspend()和 resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个线程产生了结果后，调用 resume()使其恢复。
注意区别：
初看起来wait() 和 notify() 方法与suspend()和 resume() 方法对没有什么分别，但是事实上它们是截然不同的。区别的核心在于，前面叙述的suspend()及其它所有方法在线程阻塞时都不会释放占用的锁（如果占用了的话），而wait() 和 notify() 这一对方法则相反。
扫一扫
2795
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
