3.1等待/通知机制（wait/notify）

wait/notify

要点	wait()
执行前	在调用wait（）之前，必须先要获得对象锁，即只有在同步方法或者同步代码块中调用wait（）方法。
执行作用	wait（）使进程进入等待（阻塞状态），在收到通知或者被中断之前都会进入预执行队列。
执行之后1	执行wait（）之后，当前线程释放改对象锁，在通知前与其他线程重新竞争资源
执行之后2	执行wait（）之后，如果没有使用notify（）通知其他线程，即使该对象资源空闲，其他使用过wait（）线程由于没有通知会继续阻塞直到这个对象发出notify或者notifyAll
/	wait（）是Object对象的方法。

---

要点	notify()
执行前	在调用notify()之前，必须先要获得对象锁，即只有在同步方法或者同步代码块中调用notify（）方法。
执行作用	通知一个等待该对象资源的线程进入就绪状态，如果有多个线程等待，怎有线程规划器来挑选一个进入就绪状态（区别notify和notifyAll）
执行之后	执行notify之后，当前线程并不会立即释放锁，只有当执行完sychronized方法或者代码块的时候，当前线程才会释放锁
/	notify（）是Object对象的方法。

wait（）之后锁立即释放和notify（）之后锁不立即释放

针对上面的锁释放不释放，来做一个小的例子

先做wait（）之后锁立即释放

package com.myObject;

public class Object1 {

    public void mothd1(Object lock) {
        synchronized (lock) {
            try {
                System.out.println("wait begin");
                lock.wait();
                System.out.println("wait end");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.myThread;

import com.myObject.Object1;

public class Thread1a extends Thread {
    Object lock;
    Object1 object1 = new Object1();

    public Thread1a(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object1.mothd1(lock);
    }
}

package com.myThread;

import com.myObject.Object1;

public class Thread1b extends Thread {
    Object lock;
    Object1 object1 = new Object1();

    public Thread1b(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object1.mothd1(lock);
    }
}

package com.test;

import com.myThread.Thread1a;
import com.myThread.Thread1b;

public class Test1 {
    public static void main(String[] args){
        Object lock = new Object();
        Thread1a thread1a = new Thread1a(lock);
        thread1a.start();
        Thread1b thread1b = new Thread1b(lock);
        thread1b.start();

    }
}

打印结果

wait begin
wait begin


下面是验证notify（）之后锁不立即释放

package com.myObject;

public class Object1 {

    public void mothd1(Object lock) {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName()+" wait begin " + System.currentTimeMillis());
                lock.wait();
                System.out.println(Thread.currentThread().getName()+" wait end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public void mothd2(Object lock) {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName()+"notify begin " + System.currentTimeMillis());
                lock.notify();
                Thread.sleep(5000);//延时用于测试是否有立即释放锁
                System.out.println(Thread.currentThread().getName()+"notify end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.myThread;

import com.myObject.Object1;

public class Thread1a extends Thread {
    Object lock;
    Object1 object1 = new Object1();

    public Thread1a(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object1.mothd1(lock);
    }
}

package com.myThread;

import com.myObject.Object1;

public class Thread1b extends Thread {
    Object lock;
    Object1 object1 = new Object1();

    public Thread1b(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object1.mothd2(lock);
    }
}

package com.test;

import com.myThread.Thread1a;
import com.myThread.Thread1b;

public class Test1 {
    public static void main(String[] args) throws InterruptedException{
        Object lock = new Object();
        Thread1a thread1a = new Thread1a(lock);
        thread1a.setName("A");
        thread1a.start();
        Thread.sleep(1000);
        Thread1b thread1b = new Thread1b(lock);
        thread1b.setName("B");
        thread1b.start();

    }
}

打印结果

A wait begin 1453090470087
Bnotify begin 1453090471088
Bnotify end 1453090476088
A wait end 1453090476088

说明notify必须在执行完synchronized同步方法或者同步代码块之后才释放锁

wait之后使用interrupt

package com.myObject;

public class Object2 {

    public void mothd1(Object lock) {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName()+" wait begin " + System.currentTimeMillis());
                lock.wait();
                System.out.println(Thread.currentThread().getName()+" wait end " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }


}

package com.myThread;

import com.myObject.Object2;

public class Thread2 extends Thread {
    Object lock;
    Object2 object2 = new Object2();

    public Thread2(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        object2.mothd1(lock);
    }
}

package com.test;

import com.myThread.Thread2;

public class Test2 {
    public static void main(String[] args) throws InterruptedException{
        Object lock = new Object();
        Thread2 thread2 = new Thread2(lock);
        thread2.setName("A");
        thread2.start();
        Thread.sleep(1000);
        thread2.interrupt();

    }
}

当线程处于wait（）时，调用线程对象的interrupt（）会出现InterruptedException

总结：释放锁的时刻有
1）同步代码完成
2）抛出异常或者return
3）wait（）方法