Java 多线程 --- 线程协作 wait/notify

wait / notify

• 在多线程中, 如果程序拿到锁之后, 但是没有满足指定条件而不能继续往下执行, 我们可以将当前线程暂停(进入阻塞状态), 直到满足所需要的条件时再将线程唤醒, 结构如下:

atomic {
	while (条件 不成立) {
		 wait //暂停当前线程
	}
	//执行目标动作
	doAction();
	notify
}

• 上述操作必须是原子操作. 一个线程因其执行目标动作所需的条件为满足而被暂停的过程就是等待 (Wait)
• 一个线程使用完critical section. 更新了系统的状态, 使得其他线程所需的保护条件得以,满足的时候唤醒那些被暂停的线程的过程就被称为通知 (Notify)

Object.wait() , Object.notify() / notifyAll()

• Java中通过 Object.wait() 和 Object.notify() 实现等待和通知.

• wait和notify都是Object的方法, 也就是每个对象都有wait和notify方法

• wait()的作用是使正在执行的线程被阻塞
• notify()的作用是唤醒一个被阻塞的线程.
• notifyAll()的作用是唤醒全部被阻塞的线程
• 具体格式如下

sychrnoized(lock) {
	while (条件 不成立) {
		 lock.wait //暂停当前线程
	}
	//执行目标动作
	doAction();
	lock.notify
}

Example:

给你一个类：
public class Foo {
  public void first() { print("first"); }
  public void second() { print("second"); }
  public void third() { print("third"); }
}
三个不同的线程 A、B、C 将会共用一个 Foo 实例。

线程 A 将会调用 first() 方法
线程 B 将会调用 second() 方法
线程 C 将会调用 third() 方法

请设计修改程序，以确保 second() 方法在 first() 方法之后被执行，third() 方法在 second() 方法之后被执行。

public class Foo {
    
    private int flag = 0;
    //声明一个objetc作为锁
    private Object lock = new Object();
    public Foo() {

    }
    public void first(Runnable printFirst) throws InterruptedException {
        synchronized (lock){
            while( flag != 0){
                //还没有轮到自己运行, 进入阻塞状态. 
                lock.wait();
            }
            printFirst.run();
            flag = 1;
            //唤醒其他在阻塞状态的线程
            lock.notifyAll();
        }
    }
    public void second(Runnable printSecond) throws InterruptedException {
        synchronized (lock){
            while (flag != 1){
                lock.wait();
            }
            printSecond.run();
            flag = 2;
            lock.notifyAll();
        }
    }
    public void third(Runnable printThird) throws InterruptedException {
        synchronized (lock){
            while (flag != 2){
                lock.wait();
            }
            printThird.run();
            flag = 0;
            lock.notifyAll();
        }
    }
}

notify 和 wait 的原理

• 每个sychronizied锁(也就是内部锁), 都有一个monitor对象
• monitor对象有三个部分

• The Owner: 表示目前锁的持有者, 如果为null则表示是无锁状态
• Entry Set: 记录等待获得相应内部锁的线程. 多个线程申请同一个锁的时候, 只有一个申请者能够成为该锁的持有线程, 其他申请失败者会继续保留在Entry Set.
• Wait Set: 当一个线程获得锁之后, 因为没有满足某些条件而不得不放弃锁 (调用wait方法). 会被放入Wait Set并进入阻塞状态

• 我们知道 Java 虛拟机会为每个锁(也就是对象)维护一个入口集(Entry Set ）用于存储申请该对象的内部锁的线程。
• 此外，Java 虛拟机还会为每个锁(也就是对象) 维护一个被称为等待集（Wait Set )的队列，该队列用于存储该对象上的等待线程。
• wait方法会将当前线程放进 Wait Set, 并把当前线程变为阻塞状态
• notify方法会使该对象的Wait Set中的一个任意线程被唤醒。注意此时线程不会释放锁, 要等待临界区运行完毕, 所以notify尽量放在临界区的末尾.
• 被唤醒的线程仍然会停留在相应对象的Wait Set中，直到该线程再次竞争相应内部锁的时候, Object.wait会使当前线程从其所在的Wait Set中移除.(应该是不管竞争失败或者成功都会被移除, 不过这一点不确定)接着 Object.wait调用就返回了. (具体如伪代码所示)

• Object. waito/notify()实现的等待/通知中的几个关键动作，包括将当前线程加入等待集, 暂停当前线程, 释放锁以及将唤醒后的等待线程从等待集中移除等，都是在 Obiect.wait() 中实现的.
• Object. wait() 的部分内部实现相当于如下伪代码：

public void wait () {
	//执行线程必须持有当前对象对应的内部锁
	if (!Thread.holdsLock (this) ) {
		throws new IllegalMonitorStatefxception():
	}
	if (当前对象不在等待集中）{
		//将当前线程加入当前对象的等待集中
		addToWaitSet(Thread.currentThread ());
	}
	atomic { 
		//原子操作开始, 释放当前对象的内部锁
		releaselock(this) :
		//阻塞当前线程
		block(Thread. current Thread ());
	}
	
	//再次申请当前对象的内部锁
	acquireLock(this);
	//将当前线程从当前对象的等待集中移除
	removeFromWaitSet(Thread. currentIhread () ) ;
	return;
}

notify会导致死锁的问题

• 多个线程调用了锁对象的wait()方法，这些线程都会进入到wait set中，等待池中的线程不参与锁竞争。此时只调用一次notify()方法，那么只有一个线程会从wait set进入到entry set竞争资源，并且获得锁资源继续执行接下来的代码。执行完毕后，释放锁。但是由于其它线程都处于等待池中，不会去竞争争夺锁，大家都在等待池中等待通知，故而造成了死锁。除非再次调用notify()或者notifyAll()去触发通知，否则会一直等待下去
• 如果使用notifyAll则可以避免这种情况, 因为notifyAll会唤醒所有等待线程, 放入entry set中

wait / notify的开销以及问题

To be continued