线程间的通信

/*
 * 线程间的通信：
 * 其实就是多个线程在操作同一个资源，但是操作的动作不同。
 * 
 */
//资源文件
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 (Exception e) {
}
this.name=name;
this.sex=sex;
flag=true;
//唤醒同一锁的线程
this.notify();
}
public synchronized void out()
{
if(!flag)
try {
//线程等待
this.wait();
} catch (Exception e) {

}
System.out.println(name+"====="+sex);
flag=false;
//唤醒同一锁的线程
this.notify();
}
}
//输入操作，定义类实现Runnable接口
class Input implements Runnable{
private Res r;//定义一个资源对象引用
//构造函数，以资源对象为参数
Input(Res r)
{
this.r=r;
}
//复写run方法。
public void run()
{
int x=0;
//实现多个数据测试
while (true)
{

if(x==0)
{
r.set("mike", "man");
}
//实现第二个数据输入
else 
{
r.set("lili", "女");
}
//实现数据的交替输入
x=(x+1)%2;


}


}
}
//定义输出操作，实现Runnable接口
class Output implements Runnable{
//定义资源对象引用
private Res r;
//构造函数，以对象为参数
Output(Res r)
{
this.r=r;
}
//复写run方法。
public void run()
{
//实现数据的输出
while (true)
//同步代码块对输出进行加锁，锁为r
r.out();
}
}
public class InDemo {


public static void main(String args[])
{
//定义资源对象。
Res r=new Res();
//匿名对象调用start方法
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
}
}
/*
 * wait()
 * notify()
 * notifyAll()
 * 都使用在同步中，因为对持有监视器(锁)的线程操作。
 * 所以要使用在同步中，因为只有同步才具备锁。
 * 为什么这些操作线程的方法要定义在object类中呢？
 * 因为这些方法在操作同步线程时，都必须要表示它们所操作线程持有的锁。
 * 只有同一个锁上的被等待线程，可以被同一个锁闪notify唤醒。
 * 不可以对不同锁中的线程进行唤醒。
 * 等待和唤醒必须是同一个锁。
 * 而锁可以是任意对象，所以将可以被任意对象调用的方法定义在object类中。
 */