并发编程基础之生产者消费者模式

最新推荐文章于 2025-08-08 22:01:10 发布

WWWWWWWWolf

最新推荐文章于 2025-08-08 22:01:10 发布

阅读量71

点赞数

文章标签： java

本文介绍了一个使用Java实现的生产者消费者模式示例。通过定义一个包含LinkedList容器的MyQueue类来实现生产者与消费者的交互。当容器为空时，消费者进入等待状态；当容器满时，生产者进入等待状态。

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

一：概念

生产者消费者模式是java并发编程中很经典的并发情况，首先有一个大的容器，生产者put元素到

容器中，消费者take元素出来，如果元素的数量超过容器的容量时，生产者不能再往容器中put元素

，处于阻塞状态，如果元素的数量等于0，则消费者不能在从容器中take数据，处于阻塞状态。

二：示例

/**
 * 
 */
package com.hlcui.main;

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author Administrator
 *
 */
public class MyQueue {
	
	private LinkedList<String> list = new LinkedList<String>();
	
	private AtomicInteger auto = new AtomicInteger();
	
	private  int MAX_SIZE;
	
	private final int MIN_SIZE = 0;
	
	private final Object lock = new Object();
	
	public MyQueue(int mAX_SIZE) {
		super();
		MAX_SIZE = mAX_SIZE;
	}
	
	public void put(String good) {
		synchronized (lock) {
			while(list.size()==MAX_SIZE) {
				try {
					//如果容器中物品的数量达到上限，那么就阻塞线程
					System.out.println("容器已满");
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			list.add(good);
			auto.incrementAndGet();
			lock.notify();
		}
		
	}
	
	public String take() {
		String s = null;
		synchronized (lock) {
			while(list.size()==MIN_SIZE) {
				try {
					System.out.println("容器已空");
					lock.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			s = list.removeFirst();
			auto.decrementAndGet();
			lock.notify();
		}
		return s;
	}
	
	public int size() {
		return list.size();
	}

	public static void main(String[] args) {
		final MyQueue queue = new MyQueue(5);
		for(int i=0;i<5;i++) {
			queue.put(i+"");
		}
		System.out.println("目前容器中元素数量："+queue.size());
		ExecutorService executors = Executors.newFixedThreadPool(2);
		executors.execute(new Runnable() {
			@Override
			public void run() {
				for(int i=10;i<20;i++) {
					queue.put(i+"");
					System.out.println("添加元素："+i+"");
				}
			}
		});
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		executors.execute(new Runnable() {
			@Override
			public void run() {
				for(int i=0;i<50;i++) {
					System.out.println("取出元素："+queue.take());
				}
			}
		});
	}
}