目录
1、线程循环等待的弊端
2、用 synchronized 实现等待 - 通知机制(Guarded Blocks)
3、使用Guarded Blocks,构建一个更好地资源分配器
4、尽量使用 notifyAll()的原因
5、wait()和sleep()区别
6、附:什么是 Guarded Blocks(代码保护块)?
1、线程循环等待的弊端
上一篇文章,在破坏占用且等待条件的时候,如果转出账本和转入账本不满足同时在文件架上这个条件,就用死循环的方式来循环等待,核心代码如下:
// 一次性申请转出账户和转入账户,直到成功
while(!actr.apply(this, target));
太消耗 CPU 了。// 循环等待会占用CPU资源
循环等待的弊端:当并发量冲突较大时,有可能需要循环上万次,比较消耗CPU,比较好的解决方案:当条件不满足时,不是循环等待,而是线程阻塞自己,进入等待状态(这时候是不消耗cpu的), 当条件满足时,通知等待的线程重新执行。
一个完整的等待 - 通知机制:线程首先获取互斥锁,当线程要求的条件不满足时,释放互斥锁,进入等待状态;当要求的条件满足时,通知等待的线程,重新获取互斥锁。
// 需要注意的是:由于涉及到线程阻塞和唤醒的操作,因此 wait()
方法会进入到内核模式。想想CAS操作,自旋锁的实现
2、用 synchronized 实现等待 - 通知机制(Guarded Blocks)
synchronized 配合 wait()、notify()、notifyAll() 这三个方法就能轻松实现。
左边有一个等待队列。同一时刻,只允许一个线程进入 synchronized 保护的临界区,当有一个线程进入临界区后,其他线程就只能进入图中左边的等待队列里等待。这个等待队列和互斥锁是一对一的关系,每个互斥锁都有自己独立的等待队列。// 锁和等待队列是一对一的关系
当调用 wait() 方法后,当前线程就会被阻塞,并且进入到右边的等待队列中。 线程在进入右边等待队列的同时,会释放持有的互斥锁,线程释放锁后,其他线程就有机会获得锁,并进入临界区了。
那线程要求的条件满足时,该怎么通知这个等待的线程呢?
当条件满足时调用 notify(),会通知等待队列(右边的等待队列)中的线程,告诉它条件曾经满足过。
为什么说是曾经满足过呢?
notify() 只能保证在通知时间点,条件是满足的。而被通知线程的执行时间点和通知的时间点基本上不会重合,所以当线程执行的时候,很可能条件已经不满足了(保不齐有其他线程插队)。 // 这就是为什么要使用while(),不使用if()的原因
被通知的线程要想重新执行,仍然需要获取到互斥锁(因为曾经获取的锁在调用 wait() 时已经释放了)。wait()、notify()、notifyAll() 方法操作的等待队列是互斥锁的等待队列,所以这三个方法能够被调用的前提是已经获取了相应的互斥锁,他们都是在 synchronized{}内部被调用的。
如果在 synchronized{}外部调用,JVM 会抛出一个运行时异常:java.lang.IllegalMonitorStateException。
3、使用Guarded Blocks,构建一个更好地资源分配器
在这个等待 - 通知机制中,我们需要考虑以下四个要素。
- 互斥锁:上一篇文章中提到 Allocator 需要是单例的,所以我们可以用 this 作为互斥锁。
- 线程要求的条件:转出账户和转入账户都没有被分配过。
- 何时等待:线程要求的条件不满足就等待。
- 何时通知:当有线程释放账户时就通知。
需要注意的是我们使用了经典范式:
while(条件不满足) {
wait();
}
范式,意味着是经典做法,所以没有特殊理由不要尝试换个写法。
class Allocator {
private List<Object> als = new ArrayList<>();
// 一次性申请所有资源
synchronized void apply(Object from, Object to) {
// 经典写法
while (als.contains(from) || als.contains(to)) {
try {
wait(); // 不符合条件等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
als.add(from);
als.add(to);
}
// 归还资源
synchronized void free(Object from, Object to){
als.remove(from);
als.remove(to);
notifyAll();// 通知所有线程
}
}
class Accounts {
// actr应该为单例
private Allocator actr;
private int balance;
// 转账
void transfer(Accounts target, int amt){
// 一次性申请转出账户和转入账户,直到成功
actr.apply(this, target);
try{
// 锁定转出账户-保证可见性
synchronized(this){
// 锁定转入账户
synchronized(target){
if (this.balance > amt){
this.balance -= amt;
target.balance += amt;
}
}
}
} finally {
actr.free(this, target);
}
}
}
4、尽量使用 notifyAll()的原因
使用 notify() 有风险,它的风险在于随机通知一个线程,可能导致某些线程永远不会被通知到。
所以除非经过深思熟虑,否则尽量使用 notifyAll()。
5、wait()和sleep()区别
wait() 和 sleep() 都是 Java 中用于线程等待的方法,但二者有以下区别:
- wait() 和 notify()/notifyAll() 一起使用,用于实现线程间的协作,而 sleep() 用于线程休眠一段时间。
- wait() 是 Object 类中的方法,而 sleep() 是 Thread 类中的方法。
- wait() 方法会释放占有的锁,进入等待池中等待被唤醒,而 sleep() 方法不会释放锁。
- wait() 方法只能在同步方法或同步块中调用,而 sleep() 方法可以在任何地方调用。
简单来说,wait() 和 notify()/notifyAll() 是用于线程间通信的,而 sleep() 是用于线程暂停一段时间的。
6、附:什么是 Guarded Blocks(代码保护块)?
Guarded Blocks 是一种线程间通信的方式,它能够确保某个条件成立时才能执行相应的操作。Guarded Blocks 的基本思想是:线程在循环中等待某个条件成立,一旦条件成立,就执行相应的操作。它的主要优点是能够避免线程在等待条件成立时浪费 CPU 资源,同时也能避免条件被错误地设置。// 线程经常需要协调它们的动作。最常见的协调方式就是保护块。
Guarded Blocks 的实现方式通常有以下步骤:
- 在共享对象上加锁,以确保线程互斥地访问共享对象。
- 在循环中检查某个条件,如果条件不成立,则调用共享对象的 wait() 方法进入等待状态,释放锁并让其他线程访问共享对象。
- 如果条件成立,则执行相应的操作,并通过共享对象的 notify() 或 notifyAll() 方法通知等待线程条件已经成立。
- 重复步骤 2 和 3 直到完成任务。
Guarded Blocks 的典型应用场景包括生产者-消费者模型、任务调度等。在生产者-消费者模型中,生产者会在缓冲区已满时等待,消费者会在缓冲区为空时等待。这样,就能够避免生产者在缓冲区已满时浪费 CPU 资源,消费者在缓冲区为空时等待。
Guarded Blocks 的实现通常使用 synchronized 块和 wait()、notify() 或 notifyAll() 方法来实现。需要注意的是,在使用 wait() 方法等待时,需要在循环中判断条件,以避免虚假唤醒问题。
Guarded Blocks 是通过使用一个共享变量作为条件,等待条件满足或者条件变化的方式来进行线程间的通信和协作。以下是一个使用 Guarded Blocks 实现线程协作的示例代码:
public class GuardedBlocksExample {
private boolean isDataReady = false;
private final Object lock = new Object();
public void produceData() {
synchronized (lock) {
// 生产数据
// ...
// 标记数据已准备好
isDataReady = true;
// 唤醒等待的线程
lock.notifyAll();
}
}
public void consumeData() throws InterruptedException {
synchronized (lock) {
while (!isDataReady) {
// 等待数据准备好
lock.wait();
}
// 消费数据
// ...
// 重置标记
isDataReady = false;
}
}
}
在上面的示例中,isDataReady 变量被用作条件变量,用于表示数据是否准备好。produceData() 方法负责生产数据,并在数据准备好之后,通过调用 lock.notifyAll() 方法唤醒等待的线程;consumeData() 方法则负责消费数据,并在数据未准备好时等待,直到 isDataReady 变为 true。
使用 Guarded Blocks 的关键点在于:
- 所有使用共享变量的线程都必须在同一个对象上进行同步(如上面的示例中的 lock 对象);
- 在等待条件满足时,使用 wait() 方法释放锁,以允许其他线程访问共享变量,直到被唤醒时再次获得锁;
- 在条件满足时,使用 notify() 或 notifyAll() 方法唤醒等待的线程,以便它们可以继续执行。
使用 Guarded Blocks 能够有效地避免竞态条件和死锁等问题,同时也可以提高程序的可读性和可维护性。
摘录:Guarded Blocks Java 官方文档实现生产者-消费者模型代码
在本例中,数据是一系列文本消息,它们通过Drop类的对象进行共享:
public class Drop {
private String message;
private boolean empty = true;
public synchronized String take() {
while (empty) {
try {
wait();
} catch (InterruptedException e) {}
}
empty = true;
notifyAll();
return message;
}
public synchronized void put(String message) {
while (!empty) {
try {
wait();
} catch (InterruptedException e) {}
}
empty = false;
this.message = message;
notifyAll();
}
}
在Producer中定义的生产者线程发送一系列的消息。字符串“DONE”表示所有消息都已发送。为了模拟真实应用程序的不可预测性,生产者线程在消息之间随机暂停。
import java.util.Random;
public class Producer implements Runnable {
private Drop drop;
public Producer(Drop drop) {
this.drop = drop;
}
@Override
public void run() {
String importantInfo[] = {
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too"
};
Random random = new Random();
for (int i = 0; i < importantInfo.length; i++) {
drop.put(importantInfo[i]);
try {
Thread.sleep(random.nextInt(5000));
} catch (InterruptedException e) {}
}
drop.put("DONE");
}
}
在Consumer中定义的消费者线程只是检索消息并将其打印出来,直到它检索到“DONE”字符串。这个线程也会以随机的间隔暂停。
import java.util.Random;
public class Consumer implements Runnable {
private Drop drop;
public Consumer(Drop drop) {
this.drop = drop;
}
@Override
public void run() {
Random random = new Random();
for (String message = drop.take(); !message.equals("DONE"); message = drop.take()) {
System.out.format("MESSAGE RECEIVED: %s%n", message);
try {
Thread.sleep(random.nextInt(5000));
} catch (InterruptedException e) {
}
}
}
}
最后,这是在ProducerConsumerExample中定义的主线程,它启动生产者和消费者线程。
public class ProducerConsumerExample {
public static void main(String[] args) {
Drop drop = new Drop();
(new Thread(new Producer(drop))).start();
(new Thread(new Consumer(drop))).start();
}
}
文档地址,请点击这里。
// 以上这些代码值得好好的查看和思考,能优雅写出线程之间的相互协作程序