Java基础笔记-第八记

Java 线程

wait()

notify()

notifyAll()

都使用在同步中，因为要对持有监视器的线程操作

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

为什么这些操作的方法要定义Object类中呢？

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

只有同一个锁上的被 等待纯种，可以被同一个锁上notify() 唤醒

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

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

例如:

class Res{ //添加资源类
	private String name;
	private String sex;
	
	//添加同步锁方法，用于设置姓名和年龄
	public synchronized void set(String name,String sex) {
		this.name = name;
		this.sex = sex;
	}
	
	//输出姓名和年龄
	public void out(){
		System.out.println(name+"...."+sex);
	}
	
	boolean flag = false; //标识是否已设置，true为已设置，false为未设置
}

class Input implements Runnable{  //输入线程

	private Res r ; //引用资源类

	Input(Res r){ //构造
		this.r = r;
	}
	@Override
	public void run() {  //线程
		boolean b = true;   //用于交替添加
		
		while(true){
			synchronized(r){
				if(r.flag){
					try {
						 r.wait();
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
				}
				if(b){
					r.set("jack", "男");
					b = false;
				} else{
					r.set("lili", "女");
					b = true;
				}
				r.flag = true;  //标识为已设置
				r.notify();//唤醒另一个线程，注意，另一个线程锁定的是同一个对象，否则无法唤醒
			}
		}
	}
	
}

class Output implements Runnable{ //输出线程

	private Res r;

	Output(Res r){
		this.r = r;
	}
	@Override
	public void run() {

		while(true){
			synchronized(r){ //线程锁
				if(!r.flag){//判断如果没有设置
					try {
						r.wait(); //则当前线程等待
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
				}
				r.out(); //打印内容
				r.flag = false;  //打印完成设置标识
				r.notify();   //唤醒另一个在同一个锁的线程
			}
		}
	}
}



public class Demo1 {
	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();
	}

}