notify的唤醒

1：notify执行后，该线程不会立刻结束，也并没有让出CUP，而是要执行完notify后面的内容后才结束（或者被阻塞，被阻塞时让出了CUP）；

2：notify执行后，由于notify是对某一对象上锁，所以该notify只能唤醒同一个锁对象的；非同一锁对象不会被唤醒；

3：被notify唤醒的对象不会被立马执行，而是一个从阻塞状态到等待队列中的过程，一直到notify线程让出CUP后才开始执行；

注意，使用notify或者wait的时候，该方法要加上synchronized锁。

import java.util.concurrent.TimeUnit;

public class notify {
    static Object o = new Object();
    static Object t = new Object();
    /*唤醒用线程a */
    public static class a implements Runnable {
        public void run() {
            synchronized(o){
                System.out.println("a begin");
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                System.out.println("a begin notify");
                o.notify();
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                System.out.println("a end");
            }
        }
    }
    /*模拟阻塞的线程b 和线程a是同一个o*/
    public static class b implements Runnable{
        @Override
        public void run() {
            synchronized (o) {
                System.out.println("b begin wait");
                try {
                    o.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("b ok");
            }
        }
    }
    /*模拟阻塞的线程c 和a是不同o*/
    public static class c implements Runnable{
        @Override
        public void run() {
            synchronized (t) {
                System.out.println("c begin wait");
                try {
                    t.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("c ok");
            }
        }
    }
    
    public static void main(String[] args) {
        Thread A =new Thread(new a());
        Thread B =new Thread(new b());
        B.start();
        try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        A.start();
    }
}

这样的情况输出为：

b begin wait
a begin
a begin notify
a end
b ok

 

如果将main替换为

    public static void main(String[] args) {
        Thread A =new Thread(new a());
        Thread C =new Thread(new c());
        C.start();
        try {
			TimeUnit.MILLISECONDS.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        A.start();
    }

输出为：

c begin wait
a begin
a begin notify
a end

而且C线程永远不会结束