概述

在使用synchronized进行线程同步中介绍了依赖对象锁定线程，本篇文章介绍如何依赖对象协调线程。

同synchronized悲观锁一样，线程本身不能等待与唤醒，也是需要对象才能完成等待与唤醒的操作。

本篇主题是Object等待与唤醒。

1.在Object上有定义了以下几个方法：

• public final native void notify;

  唤醒等待在此对象上的线程，如果有个线程等待，随机唤醒一个线程

• public final native void notifyAll;

  唤醒等待此对象上的所有线程

• public final void wait ;

  让当前运行线程等待

• public final native void wait(long timeout);

  让当前线运行程等待timeout毫，直到其他线程调用notify方法或notifyAll方法的对象，或一个指定的时间已经过去

• public final void wait(long timeout, int nanos);

  让当前运行线程等待timeout++毫秒，直到其他线程调用notify方法或notifyAll方法的对象，或一个指定的时间已经过去

2.代码示例

package wang.conge.javasedemo.core.thread;

import java.util.Date;

public class WaitAndNotifyDemo{

    public static void main(String[] args){
    	Object mike = new Object;
        
    	new Thread(new TalkRunable("haoran_10", mike)).start;
    	new Thread(new TalkRunable("conge", mike)).start;
    	new Thread(new TalkRunable("haoran", mike)).start;
    }
    
    static class TalkRunable implements Runnable{
    	private String name;
    	private Object mike;
    	
    	public TalkRunable(String name , Object mike){
    		this.name = name;
    		this.mike = mike;
    	}
    	
		@Override
		public void run {
			while(true){
				synchronized (mike) {
					System.out.println(name + (new Date));
					
					mike.notifyAll;
					
					try {
						mike.wait;
					} catch (InterruptedException e) {
						e.printStackTrace;
					}
				}
			}
		}
    	
    }
}

3.流程分析

• 讲话线程。每个线程有一个名称，通过初始化赋予
• 该线程讲话前，要先拿到mike锁
• 拿到mike锁之后，讲一句话
• 唤醒等mike锁的所有线程，执行mike.notifyAll
• 让出当前mike锁，等待其他持有mike锁的线程唤醒

4.总结

• 在执行对象的唤醒之前，首先要获得该对象的锁。想象一下，我说我把mike让出去，我都没有mike，我怎么让出去？
• 线程本身不能协调，要通过共同持有的对象去协调唤醒或者等待
• 一个对象可以协调的线程，都是该对象参与的线程。
• 对比一下，一个对象是一个人，这个做的事情是线程，那么是这个人协调这些事情，而不是这些事情协调这个人。这个人也只能协调他做的事情，他没有参与的事情，跟他毛关系也没有。
• 这也解释了为什么notify, wait等函数定义在Object中，而不是Thread中。协调线程的是对象，不是线程本身，由对象持有锁，并且由对象协调线程唤醒与等待操作。