Thread线程间通讯-wait,notify

解释：

When two or more threads need access to a shared resource, they need some way to ensure that the resource will be used by only one thread at a time.

The process by which this synchronization is achieved is called threadsynchronization.

The synchronized keyword in Java creates a block of code referred to as a critical section. Every Java object with a critical section of code gets a lock associated with the object. To enter a critical section, a thread needs to obtain the corresponding object'slock.

This is the general form of the synchronized statement:

synchronized(object) {
   // statements to be synchronized
}

Here, object is a reference to the object being synchronized. A synchronized block ensures that a call to a method that is a member of object occurs only after the current thread has successfully entered object's monitor.

/**

 * 线程间通讯：

 * 其实就是多个线程在操作同一个资源

 * 但是操作的动作不同

 */

wait, notify, notifyAll()

 都是用在同步中，因为要对持有监视器（锁）的线程操作。

 所以要使用在同步中，因为只有同步才具有锁。

 

 为什么这些操作线程的方法，要定义在object类中呢？

 因为这些方法在操作同步中线程时，都必须要标识他们所操作线程持有的锁，

 只有同一个锁上得被等待线程，可以被统一个锁上得notify唤醒。

 不可以对不同锁中的线程进行唤醒。

 也就是说，等待和唤醒必须是同一个锁。

 

 而锁可以是任意对象，所以可以被任意对象调用的方法（wait, notify,notifyAll）定义在object类中

举例：Input类用于，传入内容，Output类用于传出内容，由于传输的数据是共享的，所以将这个传输的数据对象作为“锁”。

等待====》唤醒

为了能够输入线程，和输出线程一次只运行一个线程，于是：输入线程工作，输出等待，输入线程等待，输出线程工作。

由于此例中进加入了两个线程，所以使用notify来唤醒wait状态下的线程。

notify 只唤醒在线程池中最上面的那个线程

notify 唤醒线程池中所有的线程

public class Input implements Runnable {

	private Res r;

	public Input(Res r) {
		super();
		this.r = r;
	}

	@Override
	public void run() {
		int x = 0;
		while (true) {
			synchronized (r) {
				if (r.flag)
					try {
						r.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				if (x == 0) {
					r.name = "LI";
					r.sex = "femal";
				} else {
					r.name = "李雷";
					r.sex = "男";
				}
				x = (x + 1) % 2;
				r.flag = true;
				r.notify();
			}
		}
	}

}

public class Output implements Runnable {

	private Res r;

	public Output(Res r) {
		super();
		this.r = r;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (r) {
				if (!r.flag)
					try {
						r.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				System.out.println(r.name + "," + r.sex);
				r.flag = false;
				r.notify();
			}
		}
	}

}

public class Res {

	String name;
	String sex;
	boolean flag = false;

}

public class InputOutputDemo {
	public static void main(String[] args) {
		Res r = new Res();
		
		Input in = new Input(r);
		Output out = new Output(r);
		
		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);
		
		t1.start();
		t2.start();
	}
}

由于共享对象是Res,可以将同步内容都放在Res中：

public class Res {

	private String name;
	private String sex;
	private boolean flag = false;

	public synchronized void set(String name, String sex) {

		if (flag)
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		this.name = name;
		this.sex = sex;

		flag = true;
		this.notify();
	}

	public synchronized void out() {

		if (!flag)
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		System.out.println(name + "..." + sex);

		flag = false;
		this.notify();
	}

}

public class Input implements Runnable {

	private Res r;

	public Input(Res r) {
		super();
		this.r = r;
	}

	@Override
	public void run() {
		int x = 0;
		while (true) {

			if (x == 0)
				r.set("Li", "female");
			else
				r.set("李雷", "男");

			x = (x + 1) % 2;
		}
	}
}

public class Output implements Runnable {

	private Res r;

	public Output(Res r) {
		super();
		this.r = r;
	}

	@Override
	public void run() {
		while (true) {
			r.out();
		}
	}

}

public class InputOutputDemo {
	public static void main(String[] args) {
		Res r = new Res();

		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();

	}
}