目录
1.1 使用Object的wait()和notify()方法
1. 线程等待唤醒机制
在JUC（Java Util Concurrent）并发编程中，线程等待唤醒机制是实现线程之间协作和同步的重要手段。这种机制允许一个线程挂起等待某个条件满足后被唤醒，以及另一个线程在满足某个条件后唤醒等待的线程。在Java中，有多种实现线程等待唤醒机制的方式，包括使用Object的wait()和notify()方法、Condition接口以及LockSupport类。
1.1 使用Object的wait()和notify()方法
Object类是Java中所有类的父类，在多线程编程中，我们可以利用Object的wait()和notify()方法实现线程等待唤醒机制。这种方式需要在同步代码块中进行操作，因为wait()和notify()方法必须在同步块中调用。
public class WaitNotifyExample {
public static void main(String[] args) {
final Object lock = new Object();
Thread waitingThread = new Thread(() -> {
synchronized (lock) {
System.out.println("Waiting thread: Started waiting...");
try {
lock.wait(); // 线程等待，释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Waiting thread: Resumed!");
}
});
Thread notifyingThread = new Thread(() -> {
synchronized (lock) {
System.out.println("Notifying thread: Started notifying...");
lock.notify(); // 唤醒等待线程
System.out.println("Notifying thread: Finished notifying");
}
});
waitingThread.start();
try {
Thread.sleep(1000); // 确保等待线程先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
notifyingThread.start();
}
}
在上面的示例中，我们创建了两个线程：waitingThread和notifyingThread。waitingThread首先获取锁并调用lock.wait()，进入等待状态，并释放了锁。接着，notifyingThread获取锁，调用lock.notify()唤醒了等待线程。注意，wait()和notify()方法都必须在synchronized块内部使用，否则会抛出IllegalMonitorStateException。
1.2 使用Condition接口
Condition接口是Java并发包（java.util.concurrent.locks）中的一部分，它提供了类似于Object的wait()和notify()方法的功能，但更加灵活。可以在一个Lock对象上通过Condition来实现线程的等待和唤醒。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionExample {
public static void main(String[] args) {
final Lock lock = new ReentrantLock();
final Condition condition = lock.newCondition();
Thread waitingThread = new Thread(() -> {
lock.lock();
try {
System.out.println("Waiting thread: Started waiting...");
condition.await(); // 线程等待
System.out.println("Waiting thread: Resumed!");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});
Thread notifyingThread = new Thread(() -> {
lock.lock();
try {
System.out.println("Notifying thread: Started notifying...");
condition.signal(); // 唤醒等待线程
System.out.println("Notifying thread: Finished notifying");
} finally {
lock.unlock();
}
});
waitingThread.start();
try {
Thread.sleep(1000); // 确保等待线程先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
notifyingThread.start();
}
}
在上述示例中，我们使用了ReentrantLock作为锁，通过调用lock.newCondition()创建了一个与该锁关联的Condition实例。然后，等待线程在等待前调用condition.await()进行等待，而唤醒线程通过condition.signal()来唤醒等待的线程。
1.3 使用LockSupport类
LockSupport类是Java并发包（java.util.concurrent.locks）中的工具类，它提供了一种基于线程的阻塞和唤醒机制，不需要依赖于特定的对象实例。
LockSupport的实现依赖于每个线程持有的一个许可（permit）。线程调用park()方法时，如果它持有许可，则立即返回；否则，将会阻塞（挂起）。线程调用unpark(Thread thread)方法时，如果线程处于挂起状态且持有许可，则会使其恢复运行。如果线程尚未调用park()方法或之前已经调用过unpark()方法，并且还持有许可，则后续的park()调用将不会阻塞。而Object类实现线程等待唤醒机制中先notify再wait就会一直处于阻塞状态，Condition接口同理。
LockSupport使用了类似信号量的机制，只有一个许可可供线程使用。如果一个线程调用了unpark(Thread thread)方法，而目标线程还没有调用park()方法，那么目标线程在之后调用park()方法时将立即返回，而不会阻塞。
在内部实现上，LockSupport使用了一些底层的Java本地接口（JNI）来实现线程的挂起和恢复。它通过修改线程的内部状态来达到挂起和恢复线程的目的。
import java.util.concurrent.locks.LockSupport;
public class LockSupportExample {
public static void main(String[] args) {
Thread waitingThread = new Thread(() -> {
System.out.println("Waiting thread: Started waiting...");
LockSupport.park(); // 线程挂起
System.out.println("Waiting thread: Resumed!");
});
Thread notifyingThread = new Thread(() -> {
System.out.println("Notifying thread: Started notifying...");
LockSupport.unpark(waitingThread); // 唤醒线程
System.out.println("Notifying thread: Finished notifying");
});
waitingThread.start();
try {
Thread.sleep(1000); // 确保等待线程先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
notifyingThread.start();
}
}