当需要多个线程共同完成一件任务，而且需要有规律的执行，那么多个线程之间需要一定的通信机制，可以协调他们的工作，以此实现多线程共同操作一份数据。
这是一种线程间的协作机制，与争夺锁的竞争机制相对应，当一个线程满足某个条件时，就进入等待状态( wait/wait(m) )，等到其他线程执行完指定的代码后，再将其唤醒，或者可以指定时间，到时间了自动唤醒，有多个线程等待时，如果有需要，可以notifyAll()唤醒所有等待的线程，wait/notify就是一种线程间的协助机制。
wait()、notify()和notifyAll()都是java.lang.Object中的方法，这说明在Java语言的设计中，任何对象都能充当同步监视器（锁）
作用：使当前线程等待，直到其他线程调用相同对象的notify()或notifyAll()方法，或者线程被中断。
使用场景：当一个线程需要等待某个条件发生时，比如资源可用、状态改变等。
条件：调用wait()方法时，当前线程必须持有该对象的监视器锁（synchronized），否则会抛出 IllegalMonitorStateException 异常。
synchronized (lock) {
while (condition) {
lock.wait(); // 释放锁并等待
}
// 条件满足后的操作
}作用：唤醒在该对象上等待的一个线程。如果有多个线程在等待，则随机选择一个线程唤醒。
使用场景：在某个条件被满足时，通知一个等待的线程继续执行。
synchronized (lock) {
// 修改条件
lock.notify(); // 唤醒一个等待线程
}作用：唤醒在该对象上等待的所有线程。
使用场景：当条件变化可能影响所有等待线程时，使用 notifyAll() 确保所有线程都有机会重新检查条件。
synchronized (lock) {
// 修改条件
lock.notifyAll(); // 唤醒所有等待线程
}第1次执行：假设线程1先抢到锁，进去后会先唤醒了线程2，但是锁还是线程1持有的，线程2只能等待，线程1将变量i加1变成1，wait释放锁进入等待唤醒状态。
第2次执行：线程2拿到锁后同样先唤醒了线程1，但是现在锁是线程2持有，线程1无法执行，线程2将变量i加1变成2后，wait释放锁进入等待唤醒状态。
第3次执行：线程1拿到锁还是先唤醒线程2然后将变量i加1变成3，然后wait释放锁。
……
第99次执行：线程1拿到锁还是先唤醒线程2然后执行加1将变量i变成99，然后wait释放锁。
第100次执行：线程2进来先唤醒了线程1，然后将i加到100后wait释放锁，此时循环加到100就已经完成，但是线程的执行还没有结束，被唤醒的线程1继续执行，先唤醒了线程2然后进入if判断，但是这次已经不能再加了，所以线程1没有wait就退出了while循环，离开synchronized块后自动失去锁，线程2随后自然得到锁进入synchronized块，同样判断已经不能再加了后随即也跳出while循环，线程1和线程2就都在就绪状态自然结束了，随后JVM进程退出。
public class TestAdd {
static int i = 0;
public static void main(String[] args) {
Runnable runnable = new Runnable() {
@Override
public void run() {
while (true) {
synchronized (this){
this.notify();
if (i < 100) {
System.out.println(Thread.currentThread().getName() + "---" + ++i);
}
else {
break;
}
try {
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
};
new Thread(runnable).start();
new Thread(runnable).start();
}
}
被lock.wait()阻塞了的线程，一旦被唤醒，或超时时，会从wait()方法下面的代码继续向下执行，即直接跳出if执行下面的代码，需要注意的是此时已经醒来的线程并不会再次判断if中的条件是否满足而是跳出if直接向下执行，这样就会遇到一个问题，线程阻塞期间，其他线程进行的一些操作可能造成条件改变，不能满足if中的条件了，如果不加以二次判断就继续执行，就可能导致程序出错。
synchronized (lock) {
if (条件不满足) {
lock.wait();
}
//继续执行后面操作
}Java给出的解决办法是：让wait总是出现在循环中，使用while去判断wait的条件而不是if，当使用while时，线程被唤醒后，不会继续跳出while块向下执行，而是会再判断一次while中的逻辑，如果条件不满足会继续wait，直到条件满足跳出while。
synchronized (lock) {
while (条件不满足) {
lock.wait();
}
//继续执行后面操作
}例1：如果使用if，wait中的线程被唤醒时，不会再次判断if中的条件
public class SimpleWakeupDemo {
private volatile static boolean flag = true;
private static final Object lock = new Object();
public static boolean condition() {
System.out.println(Thread.currentThread().getName() + "判断flag = " + flag);
return flag;
}
public static void main(String[] args) {
Thread t1 = new Thread() {
@Override
public void run() {
synchronized (lock) {
if (condition()) {
try {
System.out.println(Thread.currentThread().getName() +" before wait");
lock.wait();
System.out.println(Thread.currentThread().getName() +" after wait");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println(Thread.currentThread().getName() + "打印flag = " + flag);
}
}
};
Thread t2 = new Thread() {
@Override
public void run() {
synchronized (lock) {
try {
Thread.sleep(900);
lock.notifyAll();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t1.start();
t2.start();
}
}Thread-0判断flag = true
Thread-0 before wait
Thread-0 after wait
Thread-0打印flag = true如果改成while，可以看到wait结束后，会再次判断条件是否成立
while (condition()) {
try {
System.out.println(Thread.currentThread().getName() +" before wait");
lock.wait();
System.out.println(Thread.currentThread().getName() +" after wait");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}Thread-0判断flag = true
Thread-0 before wait
Thread-0 after wait
Thread-0判断flag = true
Thread-0 before wait例2：生产消费模型：两个线程操作同一变量，一个判断变量为0就加1变成1，另一个判断变量为1就减1变成0
public class SimpleWakeupDemo {
private volatile static int product = 0;
private static final Object lock = new Object();
public static void main(String[] args) {
Runnable consumer = new Runnable() {
@Override
public void run() {
synchronized (lock) {
while (product < 1) {
try {
System.out.println(Thread.currentThread().getName() + "不足");
System.out.println("before wait");
lock.wait();
System.out.println("after wait");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
product --;
System.out.println(Thread.currentThread().getName() + " = " + product);
lock.notifyAll();
}
}
};
Runnable productor = new Runnable() {
@Override
public void run() {
synchronized (lock) {
try {
Thread.sleep(900);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
while (!(product < 1)) {
try {
System.out.println(Thread.currentThread().getName() + "已满");
System.out.println("before wait");
lock.wait();
System.out.println("after wait");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
product ++;
System.out.println(Thread.currentThread().getName() + " = " + product);
lock.notifyAll();
}
}
};
for (int i = 0; i < 10; i++) {
new Thread(productor, "productor-"+i).start();
new Thread(consumer, "consumer-"+i).start();
}
}
}当使用while时，操作后的数总是0或1
productor-0 = 1
productor-3已满
before wait
consumer-8 = 0
productor-9 = 1
productor-8已满
before wait
consumer-1 = 0
productor-7 = 1
productor-6已满
before wait
consumer-6 = 0
consumer-5不足
before wait
productor-1 = 1
consumer-4 = 0
productor-4 = 1
consumer-3 = 0
productor-2 = 1
consumer-9 = 0
consumer-2不足
before wait
consumer-7不足
before wait
productor-5 = 1
consumer-0 = 0
after wait
consumer-7不足
before wait
after wait
consumer-2不足
before wait
after wait
consumer-5不足
before wait
after wait
productor-6 = 1
after wait
productor-8已满
before wait
after wait
productor-3已满
before wait
after wait
consumer-5 = 0
after wait
consumer-2不足
before wait
after wait
consumer-7不足
before wait
after wait
productor-3 = 1
after wait
productor-8已满
before wait
after wait
consumer-7 = 0
after wait
consumer-2不足
before wait
after wait
productor-8 = 1
after wait
consumer-2 = 0如果换成if，就会错误的出现其他的数字
productor-0 = 1
productor-2已满
before wait
productor-9已满
before wait
consumer-8 = 0
productor-7 = 1
productor-8已满
before wait
consumer-7 = 0
consumer-6不足
before wait
consumer-4不足
before wait
productor-6 = 1
consumer-5 = 0
productor-5 = 1
productor-4已满
before wait
consumer-3 = 0
productor-1 = 1
productor-3已满
before wait
consumer-2 = 0
consumer-9不足
before wait
consumer-1不足
before wait
consumer-0不足
before wait
after wait
productor-3 = 1
after wait
productor-4 = 2
after wait
consumer-4 = 1
after wait
consumer-6 = 0
after wait
productor-8 = 1
after wait
productor-9 = 2
after wait
productor-2 = 3
after wait
consumer-0 = 2
after wait
consumer-1 = 1
after wait
consumer-9 = 0线程互相交替执行的过程可以简记为：1判断，2干活，3通知
synchronized (Object) {
while (....) { //判断
try {
Object.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
//干活
//.........
Object.notifyAll(); //通知
} 主执行中插入其他线程m1，主线程立刻被阻塞，直到插入的线程m1执行完成。
public static void main(String s[]) {
Thread m1 = new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.getName() +" = " + i);
}
}
};
m1.setName("m1");
m1.start();
for (int i = 0; i < 100; i++) {
/**i加到20的时候，插入子线程，子线程执行完了(消亡)，主线程再继续*/
if (i == 20) {
try {
m1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() +" = " + i);
}
}volatile是一种轻量级的线程通信机制，具体见：volatile作用分析
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。