线程间的基本通信的实现

/**
 * 线程间通信：其实就是多个线程在操作同一个资源，
 * 但是操作的动作不同 出错现象，输入的和输出的对象不响应。
 * 
 * 
 * wait;notify();notifyall();
 * 都使用在同步中，因为要对持有监视器(锁)的线程操作。
 * 所以要使用在同步中，因为只有同步才具有锁。
 * 为什么这些操作线程的方法要定义Object类中呢？
 *因为这些方法在操作同步中线程时，都必须要标识他们所操作线程只有的锁，只有同一个锁上的被等待
 *线程，可以被同一个锁上的notify唤醒。不可以对不同锁中的线程进行唤醒。
 *也就是说，等待和唤醒必须是同一个锁，而锁可以是任意对象，所以可以被任意对象调用的方法
 *定义object类中
 */
public class InputOutputStreamDemo {
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();*/
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
}
}


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();
System.out.println(name+".........."+sex);
flag=false;
this.notify();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}


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.set("mike", "男"); 


} else {r.set("丽丽", "女");



}
x = (x + 1) % 2;

}
}
}






class Output implements Runnable {
private Res r;


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


@Override
public void run() {
while (true) {
r.out();
/*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();
}*/
}
}


}