Thread(线程间通讯，代码优化)

package process;

/*
 * 线程间通讯：
 * 其实就是多个线程在操作同一个资源
 * 但是操作的动作不同。
 * 
 * wait:
 * notify()
 * notifyAll()
 * 
 * 都使用在同步中，因为要对持有监视器（锁）的线程操作
 * 所以要使用在同步中，因为只有同步才具有锁
 * 
 * 为什么这些操作线程的方法要定义object类中呢？
 * 因为这些方法在操作同步中线程时，都必须要表示他们所操作线程只有的锁。
 * 只有同一个锁上的被等待线程，可以被同一个notify唤醒
 * 不可以对不同锁中的线程进行唤醒
 * 
 * 也就是说，等待和唤醒必须是同一个锁
 * 
 * 而锁可以是任意对象，所以可以被任意对象调用的方法定义object类中。
 */
class Res{
	String name;
	String sex;
	boolean flag = false;
	
	public synchronized void in(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();
	}
}

class Input implements Runnable{
	private Res s;
	Input(Res s){
		this.s = s;
	}
	public void run(){
		int x = 0;
		while(true){
			if(x == 0)
			 s.in("lili","nv");
			else 
			s.in("丽丽","女");
			
			x = (x+1)%2;
		}
	}
}

class Output implements Runnable{
	private Res s;
	Output(Res s){
		this.s = s;
	}
	public void run(){
		while(true){
			s.out();
		}
	}
} 
public class InputOutputDemo {

	public static void main(String[] args){
		Res s = new Res();
		/*Input i = new Input(s);
		Output o = new Output(s);
		
		Thread t = new Thread(i);
		Thread t1 = new Thread(o);
		t.start();
		t1.start();*/
		
		new Thread(new Input(s)).start();
		new Thread(new Output(s)).start();
		
	}
}