wait()+notify实现java生产者-消费者

最新推荐文章于 2023-01-01 17:03:11 发布

说了ye白说

最新推荐文章于 2023-01-01 17:03:11 发布

阅读量1.9k

点赞数 1

分类专栏： JAVA

本文链接：https://blog.csdn.net/wjtyy/article/details/46403455

版权

JAVA 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

（一）、问题的引出

有一个数据存储空间,划分为两部分,一部分用于存储人的姓名,另一部分用于存储人的性别;

我们的应用包含两个线程,一个线程不停向数据存储空间添加数据(生产者),另一个线程从数据空间取出数据(消费者);

因为线程的不确定性，存在于以下两种情况：
1.若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，CPU就切换到了消费者线程，消费者线程把姓名和上一个人的性别联系到一起；
2.生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者放入新的数据，又重复的取出已取过的数据；

/**
 * 模拟数据区域
 *
 */
class Person{
	
	private String name;
	
	private String sex;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}
/**
 * 生产者
 */
class Producer implements Runnable{
	
	private Person p;
	
	public Producer(Person p){
		this.p = p;
	}
	
	public void run() {
		for (int i = 0; i < 100; i++) {
			if(i % 2== 0){
				p.setName("大哥");
				try {
					Thread.sleep(2);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				p.setSex("男");
			}else{
				p.setName("小姐");
				try {
					Thread.sleep(5);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				p.setSex("女");
			}
		}
	}
}

class Consumer implements  Runnable{
	private Person p;
	
	public Consumer(Person p){
		this.p = p;
	}
	public void run() {
		for (int i = 0; i < 100; i++) {
			String name = p.getName();
			String sex = p.getSex();
			System.out.println(name+" --> " + sex);
		}
	}
	
}
public class Producer_ConsumerDemo {
	public static void main(String[] args) {
		Person p = new Person();
		
		new Thread(new Producer(p)).start();
		new Thread(new Consumer(p)).start();
	}
}

上机运行上述程序，可见问题的结果。每次运行的结果都不一样，但是都是有问题的结果。

接下来的代码是对上述程序问题的解决。当然了，就是解决： 1.若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，CPU就切换到了消费者线程，消费者线程把姓名和上一个人的性别联系到一起；2.生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者放入新的数据，又重复的取出已取过的数据；

只不过，问题1反映在本例的男女性别的混乱。问题2反映在本例的“大哥----男”和“小姐----女”不是按照我们程序设计的交替出现（生产消费）。

看改进代码：

/**
 * 模拟数据存储区域
 * 
 */
/*
 *  设置名字和性别同步完成,
 */
class Person {

	private String name;

	private String sex;

	// 表示存储区域是否为空。
	//存储区为空，消费者停止消费，生产者工作；存储区不为空，生产者停止生产，消费者开始消费
	private Boolean Empty = Boolean.TRUE;

/**
* 生产者生产人（姓名，性别）
* 
*/
	public void set(String name, String sex) {
		synchronized (this) {
			// if(Empty)
			while (!Empty.equals(Boolean.TRUE)) {
				// 区域不为空
				// 此时生产者应该停下来,等着消费者“消费”
				try {
					this.wait();// 等待 消费者消费
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
			this.name = name;
			//
			this.sex = sex;
			// 生产者生产之后,应该修改存储区域的状态以显示其存储空间有产品可供“消费”
			Empty = Boolean.FALSE;// 不为空
			this.notify();// 唤醒消费者起来“消费”，可以理解为读存储空间里的数据
		}

	}

/**
 * 消费者消费（姓名，性别）
 */
	public void get() {
		synchronized (this) {
			// 存储区域为空
			while (!Empty.equals(Boolean.FALSE)) {
				try {
					this.wait();// 等着生产者去生产
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
				
			
			}
			String name = getName();
			String sex = getSex();
			System.out.println(name + " --> " + sex);
			
			// 消费完成,应该修改存储区域的状态

			Empty = Boolean.TRUE;// 空了
			this.notify();// 唤醒生产者
		}

	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}

/**
 * 生产者
 */
class Producer implements Runnable {

	private Person p;

	public Producer(Person p) {
		this.p = p;
	}

	public void run() {
		for (int i = 0; i < 100; i++) {
			if (i % 2 == 0) {
				p.set("大哥", "男");
			} else {
				p.set("小姐", "女");
			}
		}
	}
}

class Consumer implements Runnable {
	private Person p;

	public Consumer(Person p) {
		this.p = p;
	}

	public void run() {
		for (int i = 0; i < 100; i++) {
			p.get();
		}
	}

}

public class Producer_ConsumerDemo {
	public static void main(String[] args) {
		Person p = new Person();
        //加下面的话就相当于两个生产者两个消费者
		//new Thread(new Producer(p)).start();
		//new Thread(new Consumer(p)).start();
		
		new Thread(new Producer(p)).start();
		new Thread(new Consumer(p)).start();
	}
}

</pre><pre name="code" class="java"><span style="white-space:pre"></span>

程序结果：

大哥 --> 男
小姐 --> 女
大哥 --> 男
小姐 --> 女

..................

注意：

wait():让当前线程放弃监视器进入等待，直到其他线程调用同一个监视器并调用notify()或notifyAll()为止。
notify():唤醒在同一对象监听器中调用wait方法的第一个线程。
notifyAll():唤醒在同一对象监听器中调用wait方法的所有线程。

wait()、notify()、notifyAll()，这三个方法属于Object 不属于 Thread，这三个方法必须由同步监视对象来调用，两种情况：

1.synchronized修饰的方法，因为该类的默认实例(this)就是同步监视器，所以可以在同步方法中调用这三个方法;
2.synchronized修饰的同步代码块，同步监视器是括号里的对象，所以必须使用该对象（同步监视器）调用这三个方法;

但是下面问题又来了：要是我们使用的是Lock对象来保证同步的,系统中不存在隐式的同步监视器对象,那么就不能使用者三个方法了,那该咋办呢?

解决办法：

Lock代替了同步方法或同步代码块,就用Condition来代替同步监视器的功能;
Condition对象通过Lock对象的newCondition()方法创建;
里面方法包括:
await(): 等价于同步监听器的wait()方法;
signal(): 等价于同步监听器的notify()方法;
signalAll(): 等价于同步监听器的notifyAll()方法;

具体实现情况看下面的代码：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 模拟数据区域
 * 
 * 可重入锁没有同步监听对象,咋办呢?
 * 
 * Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。 
 */
class Person {

	// 创建可重入锁对象
	private final ReentrantLock lock = new ReentrantLock();
	
	private  final  Condition con = lock.newCondition();
	private String name;

	private String sex;

	// 表示存储区域是否为空
	private Boolean Empty = Boolean.TRUE;

	/**
	 * 生产
	 * 
	 */
	public void set(String name, String sex) {
		lock.lock();
		while(!Empty.equals(Boolean.TRUE)){
			//表示不空状态
			try {
				con.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		try {
			this.name = name;
			Thread.sleep(1);
			this.sex = sex;
			isEmpty = Boolean.FALSE;
			con.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
		

	}

	/**
	 * 消费
	 */
	public void get() {
		lock.lock();
		while(!Empty.equals(Boolean.FALSE)){
			//存储区域为空,消费者应该等着
			try {
				con.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		try {
			String name = getName();
			String sex = getSex();
			System.out.println(name + " --> " + sex);
			//
			Empty = Boolean.TRUE;
			con.signal();
		} finally {
			lock.unlock();
		}
		
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}

/**
 * 生产者
 */
class Producer implements Runnable {

	private Person p;

	public Producer(Person p) {
		this.p = p;
	}

	public void run() {
		for (int i = 0; i < 100; i++) {
			if (i % 2 == 0) {
				p.set("大哥", "男");
			} else {
				p.set("小姐", "女");
			}
		}
	}
}

class Consumer implements Runnable {
	private Person p;

	public Consumer(Person p) {
		this.p = p;
	}

	public void run() {
		for (int i = 0; i < 100; i++) {
			p.get();
		}
	}

}

public class Producer_ConsumerDemo {
	public static void main(String[] args) {
		Person p = new Person();

		new Thread(new Producer(p)).start();
		new Thread(new Consumer(p)).start();

	}
}

程序结果：

大哥 --> 男
小姐 --> 女
大哥 --> 男
小姐 --> 女

........本文参考众多他人资料..........