java多线程之生产者和消费者案例

最新推荐文章于 2024-04-15 17:02:22 发布

西门吹雪叶孤城

最新推荐文章于 2024-04-15 17:02:22 发布

阅读量1.5k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： java多线程 Java基础文章标签： java生产者和消费者案例线程通信生产者和消费者多线程

本文链接：https://blog.youkuaiyun.com/yangying496875002/article/details/73610722

Java基础同时被 2 个专栏收录

98 篇文章

订阅专栏

java多线程

11 篇文章

订阅专栏

本文通过生产者和消费者的经典案例，详细介绍了线程间如何通过共享资源进行通信，并使用同步方法和Lock机制配合Condition接口实现线程间的等待和唤醒，确保线程安全。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.线程通信

不同的线程执行不同的任务,如果这些任务有某种关系,线程之间必须能够通信,协调完成工作.

经典的生产者和消费者案例(Producer/Consumer):
分析案例:
1):生产者和消费者应该操作共享的资源(实现方式来做).
2):使用一个或多个线程来表示生产者(Producer).
3):使用一个或多个线程来表示消费者(Consumer).

生产者消费者的示意图:

这里我们做一个例子

1.共享资源

//共享资源
public class ShareResource {

	private String name;
	private String gender;
	
	/**
	 * 生产者向共享资源中存储数据
	 * @param name
	 * @param gender
	 */
	public void  push(String name,String gender) {
		this.name = name;
		this.gender = gender;
		System.out.println("生产者生产:"+this.name+"-"+this.gender);
	}
	
	/**
	 * 消费从共享资源中取出数据
	 */
	public void popup() {
		System.out.println("消费者消费:"+this.name+"-"+this.gender);
	}
}

2.生产者

//生产者
public class Producer implements Runnable {
	//共享资源对象
	private ShareResource resource = null;

	public Producer(ShareResource resource) {
		this.resource = resource;
	}

	public void run() {
		for (int i = 0; i < 50; i++) {
			if (i % 2 == 0) {
				resource.push("春哥哥", "男");
			} else {
				resource.push("凤姐", "女");
			}
		}
	}

}

3.消费者

//消费者
public class Consumer implements Runnable {
	//共享资源对象
	private ShareResource resource;

	public Consumer(ShareResource resource) {
		this.resource = resource;
	}

	public void run() {
		for (int i = 0; i < 50; i++) {
			resource.popup();
		}
	}

}

4.测试

//测试类
public class Test1 {
	public static void main(String[] args) {
		//创建共享资源对象
		ShareResource resource = new ShareResource();
		
		//启动生产者消费者线程
		new Thread(new Producer(resource)).start();
		new Thread(new Consumer(resource)).start();
	}
}

结果:

此时结果也有一些问题,现在,我们需要在共享资源的生产者生产的方法和消费者消费的方法中加上Thread.sleep(10)方法来模拟网络延迟,这样我们就能让问题更明显

修改共享资源代码

//共享资源
public class ShareResource {

	private String name;
	private String gender;
	
	/**
	 * 生产者向共享资源中存储数据
	 * @param name
	 * @param gender
	 */
	public void  push(String name,String gender) {
		this.name = name;
		try {
			Thread.sleep(10);  //模拟网络延迟
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.gender = gender;
		System.out.println("生产者生产:"+this.name+"-"+this.gender);
	}
	
	/**
	 * 消费从共享资源中取出数据
	 */
	public void popup() {
		try {
			Thread.sleep(10);  //模拟网络延迟
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("消费者消费:"+this.name+"-"+this.gender);
	}
}

此时的结果

出现:凤姐-男的原因:
生产者先生产出春哥哥-男,此时消费者没有消费,生产者继续生产出姓名为凤姐,此时消费者开始消费了.
重复出现凤姐-男和凤姐-女

分析生产者和消费者案例存在的问题:
此时出现下面的情况:
问题1:出现姓别紊乱的情况.
解决方案:只要保证在生产姓名和性别的过程保持同步,中间不能被消费者线程进来取走数据.
可以使用同步代码块/同步方法/Lock机制来保持同步性.
问题2:应该出现生产一个数据,消费一个数据.

应该交替出现:

生产者生产:春哥哥-男-->凤姐-女

消费者消费:春哥哥-男-->凤姐-女

生产者生产:春哥哥-男-->凤姐-女

消费者消费:春哥哥-男-->凤姐-女

解决方案: 得使用等待和唤醒机制.

线程通信-wait和notify方法介绍:
java.lang.Object类提供类两类用于操作线程通信的方法.
wait():执行该方法的线程对象释放同步锁,JVM把该线程存放到等待池中,等待其他的线程唤醒该线程.
notify:执行该方法的线程唤醒在等待池中等待的任意一个线程,把线程转到锁池中等待.
notifyAll():执行该方法的线程唤醒在等待池中等待的所有的线程,把线程转到锁池中等待.
注意:上述方法只能被同步监听锁对象来调用,否则报错IllegalMonitorStateException..
------------------------------------------
假设A线程和B线程共同操作一个X对象(同步锁),A,B线程可以通过X对象的wait和notify方法来进行通信,流程如下:
1:当A线程执行X对象的同步方法时,A线程持有X对象的锁,B线程没有执行机会,B线程在X对象的锁池中等待.
2:A线程在同步方法中执行X.wait()方法时,A线程释放X对象的锁,进入A线程进入X对象的等待池中.
3:在X对象的锁池中等待锁的B线程获取X对象的锁,执行X的另一个同步方法.
4:B线程在同步方法中执行X.notify()方法时,JVM把A线程从X对象的等待池中移动到X对象的锁池中,等待获取锁.
5:B线程执行完同步方法,释放锁.A线程获得锁,继续执行同步方法.

修改共享资源代码中生产者生产的方法和消费者消费的方法.

//共享资源
public class ShareResource {

	private String name;
	private String gender;
	private boolean isEmpty = true;//表示共享资源是否为空的状态

	/**
	 * 生产者向共享资源中存储数据
	 * @param name
	 * @param gender
	 */
	synchronized public void push(String name, String gender) {
		try {
			while (!isEmpty) {
				this.wait(); //如果资源不为空,则生产者等待
			}
			//生产开始
			this.name = name;
			Thread.sleep(10); //模拟网络延迟
			this.gender = gender;
			System.out.println("生产者生产:" + this.name + "-" + this.gender);
			//生产结束
			this.isEmpty = false; //将共享资源状态设置为不空
			this.notify(); //生产完之后唤醒消费者

		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 消费从共享资源中取出数据
	 */
	synchronized public void popup() {
		try {
			while (isEmpty) {
				this.wait(); //如果资源为空,则消费者等待
			}
			Thread.sleep(10); //模拟网络延迟
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("消费者消费:" + this.name + "-" + this.gender);

		this.isEmpty = true; //将共享资源状态设置为空
		this.notify(); //消费完之后唤醒消费者
	}
}

执行结果:

图解:

2.上面是使用同步方法解决

下面使用Lock和Condition接口:
wait和notify方法,只能被同步监听锁对象来调用,否则报错IllegalMonitorStateException.
那么现在问题来了,Lock机制根本就没有同步锁了,也就没有自动获取锁和自动释放锁的概念.
因为没有同步锁,所以Lock机制不能调用wait和notify方法.

解决方案:Java5中提供了Lock机制的同时提供了处理Lock机制的通信控制的Condition接口.
--------------------------------------------------------------------
从Java5开始,可以:
1):使用Lock机制取代synchronized 代码块和synchronized 方法.
2):使用Condition接口对象的await,signal,signalAll方法取代Object类中的wait,notify,notifyAll方法.

同样修改共享资源代码:

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

//共享资源
public class ShareResource {

	private String name;
	private String gender;
	private boolean isEmpty = true;//表示共享资源是否为空的状态
	
	private final Lock lock = new ReentrantLock();  //创建锁对象
	private Condition condition = lock.newCondition(); //获取Condition接口的对象

	/**
	 * 生产者向共享资源中存储数据
	 * @param name
	 * @param gender
	 */
	 public void push(String name, String gender) {
		lock.lock();//加锁
		try {
			while (!isEmpty) {
				//this.wait(); //如果资源不为空,则生产者等待
				condition.await();//替换上面的wait()
			}
			//生产开始
			this.name = name;
			Thread.sleep(10); //模拟网络延迟
			this.gender = gender;
			System.out.println("生产者生产:" + this.name + "-" + this.gender);
			//生产结束
			this.isEmpty = false; //将共享资源状态设置为不空
			//this.notify(); //生产完之后唤醒消费者
			condition.signal();//替换上面的notify()

		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();//释放锁
		}
	}

	/**
	 * 消费从共享资源中取出数据
	 */
	 public void popup() {
		 lock.lock();//加锁
		try {
			while (isEmpty) {
				//this.wait(); //如果资源为空,则消费者等待
				condition.await();//替换上面的wait()
			}
			Thread.sleep(10); //模拟网络延迟
			System.out.println("消费者消费:" + this.name + "-" + this.gender);
			
			this.isEmpty = true; //将共享资源状态设置为空
			//this.notify(); //消费完之后唤醒消费者
			condition.signal();//替换上面的notify()
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally{
			lock.unlock();//释放锁
		}
	}
}

结果也是正确