java生成者消费者队列实现(全)

最新推荐文章于 2021-03-05 10:01:17 发布
原创 最新推荐文章于 2021-03-05 10:01:17 发布 · 1.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了通过信号量、管程和队列实现并发控制与资源管理的方法，包括信号量方式、管程方式以及生产者消费者队列的应用，旨在解决多线程环境下资源共享和同步的问题。

单一生产，单一消费：

信号量方式：

package test;



public class Main {
	boolean flag = true;
	int food = 0;
	class T1 extends Thread{	
		
		@Override
		public void run() {
			while(true){
				synchronized (this) {
					while(!flag){
						try {
							wait();
						} catch (InterruptedException e) {						
							e.printStackTrace();
						}
					}
				}
				synchronized (t2) {
					food++;
					System.out.println("make "+food);
					flag=!flag;
					t2.notify();
				}				
			}
		}
	}
	
	class T2 extends Thread{
		
		@Override
		public void run() {
			while(true){
				synchronized (this) {
					while(flag){
						try {
							wait();
						} catch (InterruptedException e) {						
							e.printStackTrace();
						}
					}
				}
				synchronized (t1) {
					food--;
					System.out.println("eat "+food);
					flag=!flag;
					t1.notify();
				}			
			}
		}
	}
	
	T1 t1 = new T1();
	T2 t2 = new T2();
	public static void main(String[] args) {
		Main m = new Main();					
		m.t1.start();
		m.t2.start();
	}
}

信号集

package test;

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



public class Test{		
	ReentrantLock lock1 = new ReentrantLock();//满锁
	ReentrantLock lock2 = new ReentrantLock();//空锁
	Condition c1 = lock1.newCondition();
	Condition c2 = lock2.newCondition();
	int food = 0;	
	
	class T1 extends Thread{//生产者	
		
		@Override
		public void run() {		
			while(true){
				lock1.lock();			
				while(food==1){					
					try {
						c1.await();
					} catch (InterruptedException e) {						
						e.printStackTrace();
					}
				}	
				lock1.unlock();
				lock2.lock();				
				System.out.println("生产"+(++food));					
				c2.signalAll();
				lock2.unlock();				
			}
		}
	}
	
	class T2 extends Thread{//消费者
		
		@Override
		public void run() {
			while(true){
				lock2.lock();			
				while(food==0){						
					try {						
						c2.await();
					} catch (InterruptedException e) {						
						e.printStackTrace();
					}
				}				
				lock2.unlock();
				lock1.lock();
				System.out.println("消费"+(--food));						
				c1.signalAll();
				lock1.unlock();		
			}
		}
	}
	
	T1 t1 = new T1();
	T2 t2 = new T2();
	
	public static void main(String[] args) {
		Test m = new Test();					
		m.t1.start();
		m.t2.start();
	}
}


生产者消费者队列：

信号量方式：

package test;

import java.util.Arrays;



public class Main {
	class Food{//食物类
		int num = 0;
		Food(int num){
			this.num = num;
		}
		@Override
		public String toString() {			
			return "Food"+this.num;
		}
	}
	int max = 10;
	int count = 0;//当前队列里面的Food数目
	Food[] foods = new Food[max];
	
	class T1 extends Thread{//生产者	
		
		@Override
		public void run() {
			while(true){
				synchronized (this) {
					while(count==max){
						try {
							wait();
						} catch (InterruptedException e) {						
							e.printStackTrace();
						}
					}
				}
				synchronized (t2) {
					foods[count] = new Food(count);
					count++;
					System.out.println("生产"+Arrays.toString(foods));					
					t2.notify();
				}				
			}
		}
	}
	
	class T2 extends Thread{//消费者
		
		@Override
		public void run() {
			while(true){
				synchronized (this) {
					while(count==0){
						try {
							wait();
						} catch (InterruptedException e) {						
							e.printStackTrace();
						}
					}
				}
				synchronized (t1) {
					foods[--count] = null;				
					System.out.println("消费"+Arrays.toString(foods));					
					t1.notify();
				}			
			}
		}
	}
	
	T1 t1 = new T1();
	T2 t2 = new T2();
	public static void main(String[] args) {
		Main m = new Main();					
		m.t1.start();
		m.t2.start();
	}
}
信号集
package test;

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



public class Main {
	class Food{//食物类
		int num = 0;
		Food(int num){
			this.num = num;
		}
		@Override
		public String toString() {			
			return "Food"+this.num;
		}
	}
	ReentrantLock lock1 = new ReentrantLock();//满锁
	ReentrantLock lock2 = new ReentrantLock();//空锁
	Condition c1 = lock1.newCondition();
	Condition c2 = lock2.newCondition();
	int max = 10;
	int count = 0;//当前队列里面的Food数目
	Food[] foods = new Food[max];
	
	class T1 extends Thread{//生产者	
		
		@Override
		public void run() {		
			while(true){
				lock1.lock();			
				while(count==max){					
					try {
						c1.await();
					} catch (InterruptedException e) {						
						e.printStackTrace();
					}
				}	
				lock1.unlock();
				lock2.lock();
				foods[count] = new Food(count);
				count++;
				System.out.println("生产"+Arrays.toString(foods));					
				c2.signalAll();
				lock2.unlock();				
			}
		}
	}
	
	class T2 extends Thread{//消费者
		
		@Override
		public void run() {
			while(true){
				lock2.lock();			
				while(count==0){						
					try {						
						c2.await();
					} catch (InterruptedException e) {						
						e.printStackTrace();
					}
				}				
				lock2.unlock();
				lock1.lock();
				foods[--count] = null;				
				System.out.println("消费"+Arrays.toString(foods));					
				c1.signalAll();
				lock1.unlock();		
			}
		}
	}
	
	T1 t1 = new T1();
	T2 t2 = new T2();
	public static void main(String[] args) {
		Main m = new Main();					
		m.t1.start();
		m.t2.start();
	}
}

管程方式

package test;

import java.util.Arrays;



public class Main {
	class Food{//食物类
		int num = 0;
		Food(int num){
			this.num = num;
		}
		@Override
		public String toString() {			
			return "Food"+this.num;
		}
	}
	
	int max = 10;
	int count = 0;//当前队列里面的Food数目
	static Main m = new Main();
	Food[] foods = new Food[max];
	
	synchronized void produce(){
		while(count==max){					
			try {
				wait();
			} catch (InterruptedException e) {						
				e.printStackTrace();
			}			
		}	
		foods[count] = new Food(count);
		count++;
		System.out.println("生产"+Arrays.toString(foods));	
		notifyAll();
	}
	
	synchronized void consume(){
		while(count==0){					
			try {
				wait();
			} catch (InterruptedException e) {						
				e.printStackTrace();
			}			
		}	
		foods[--count] = null;				
		System.out.println("消费"+Arrays.toString(foods));
		notifyAll();
	}			
	
	class T1 extends Thread{//生产者	
		
		@Override
		public void run() {		
			while(true){
				m.produce();
			}
		}
	}
	
	class T2 extends Thread{//消费者
		
		@Override
		public void run() {
			while(true){
				m.consume();
			}
		}
	}
	
	T1 t1 = new T1();
	T2 t2 = new T2();
	public static void main(String[] args) {
		Main m = new Main();					
		m.t1.start();
		m.t2.start();
	}
}



Java多线程-生产者消费者例子-使用队列实现
人生就像一场戏
12-23 937
生产者 /** * Producer Thread will keep producing values for Consumer * to consumer. It will use wait() method when Queue is full * and use notify() method to send notification to Consumer * Thread. * * @author WINDOWS 8 */ class Producer extends Thre
Java并发编程（1）—— 实现一个生产者消费者队列（三种方式）
Aviato
03-01 3182
生产者消费者队列，顾名思义，就是一个队列，不停地有生产者在里面生产对象并通知阻塞的消费者可以消费了，如果队列满了，生产者就阻塞不能再生产；消费者来消费（也就是读取并拿走队列里的对象）并通知阻塞的生产者，直到把队列消费空，就阻塞不能再消费。 wait/notify机制 wait/notify机制原理 wait/notify机制是与Monitor监视器锁关联在一起的。一个线程在持有某个对象的监视器...
Java多线程15：Queue、BlockingQueue以及利用BlockingQueue实现生产者/消费者模型
weixin_33743703的博客
10-05 211
Queue是什么 队列，是一种数据结构。除了优先级队列和LIFO队列外，队列都是以FIFO（先进先出）的方式对各个元素进行排序的。无论使用哪种排序方式，队列的头都是调用remove()或poll()移除元素的。在FIFO队列中，所有新元素都插入队列的末尾。   Queue中的方法 Queue中的方法不难理解，6个，每2对是一个也就是总共3对。看一下JDK API就知道了： 注意一点就...
java 队列消费者_Java阻塞队列(BlockingQueue)实现 生产者/消费者 示例
weixin_35084652的博客
02-21 281
Java阻塞队列(BlockingQueue)实现 生产者/消费者 示例Java.util.concurrent.BlockingQueue 是一个队列实现类，支持这样的操作：当从队列中获取或者移除元素时，如果队列为空，需要等待，直到队列不为空；同时如果向队列中添加元素时，此时如果队列无可用空间，也需要等待。BlockingQueue 类不接收Null值，如果你试图向队列中存入Null值将抛出Nu...
java 消费者 生产者 队列_java多线程之生产者消费者队列 | 学步园
weixin_34894242的博客
02-16 392
java多线程一般都会讲消费者-生产者模型生产者与消费者模型中，要保证以下几点：1 同一时间内只能有一个生产者生产2 同一时间内只能有一个消费者消费3 生产者生产的同时消费者不能消费4 消息队列满时生产者不能继续生产5 消息队列空时消费者不能继续消费----------------------------------------------------Message类public class Me...
rabbitmq 7种队列实现java版
01-20
文章目录rabbitmq7种实现方式搭建maven项目引入依赖创建连接简单队列消息生产者消息消费者work queues 工作队列生产者消费者能者多劳（公平分发）：消费能力强则消费更多消息Publish/Subscribe 发布订阅模式生产者...
Java实现阻塞队列+生产者消费者
程序员世杰
03-28 654
Java实现阻塞队列 package test.blockqueue; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class BlockQueue<T...
Java线程实现Redis任务队列(生产者消费者)
热门推荐
B_TAEYANG的博客
10-20 1万+
注：接上篇IDEA整合Redis，本篇实现Redis的任务队列，Redis连接池具体配置看上篇。 一：写一个Jedis的工具类JedisUtil，将Jedis中的部分方法实现，代码如下: package com.wq.Util; import com.wq.RedisPool.RedisPool; import redis.clients.jedis.Jedis; import java.
producer-java.rar_java 生产者 消费者_java 生产者消费者_producer.java_生产者 消费者
09-23
在提供的压缩包文件中，`producer.java`可能是实现生产者消费者问题的Java代码示例。通常，这样的代码会包含两个主要类：一个代表生产者，另一个代表消费者。生产者类会有一个或多个方法用于生成数据并将其放入共享...
java解决单缓冲生产者消费者问题示例
09-04
在实际应用中，生产者消费者模型可用于处理大量并发任务，例如在消息队列、数据库操作或者网络I/O等场景，其中生产者负责生成任务或数据，而消费者负责处理这些任务或数据。通过合理设计同步机制，可以实现高效的...
【Java】Queue、BlockingQueue和队列实现生产者消费者模式
12-22
文章目录1. Queue接口 – 队列1.1 ConcurrentLinkedQueue类（线程安全）2. BlockingQueue接口 – 阻塞队列2.1 ArrayBlockingQueue类（有界阻塞队列）2.2 LinkedBlockingQueue类（无界阻塞队列）3. 源码：BlockingQueue实现生产者消费者模式→ 输出结果截图 1. Queue接口 – 队列 public interface Queue extends Collection Collection的子接口，表示队列FIFO（First In First Out） 常用方法： （1）抛出异常 boole
java 基于队列实现的生产消费者模式
06-09
基于队列实现的生产消费者模式java 源码，并且采用多线程进行消费
Java语言实现生产者与消费者的消息队列模型（附源码）
千与编程
02-19 1553
package com.company; import java.util.LinkedList; /** * 生产者消费者问题 */ public class Main{ //最大容量 public static final int MAX_SIZE = 2; //存储媒介 public static LinkedList<Integer> list = new LinkedList<>(); static class Produc
用Java写一个生产者-消费者队列
weixin_30294709的博客
08-27 627
生产者消费者的模型作用 通过平衡生产者的生产能力和消费者的消费能力来提升整个系统的运行效率，这是生产者消费者模型最重要的作用。 解耦，这是生产者消费者模型附带的作用，解耦意味着生产者和消费者之间的联系少，联系越少越可以独自发展 使用阻塞队列来实现 package yunche.test.producer; import java.util.Random; impor...
java 队列 消费者模式_9.队列：生产者消费者模式
weixin_42365688的博客
03-05 285
队列：生产消费模式及线程池的运用> 关注公众号 MageByte，设置星标获取最新干货。 “加群” 进入技术交流群获更多技术成长。向固定大小的线程池投放请求任务时，若果线程池中没有空闲资源了，这时候还有新的请求进来，线程池如何处理这个请求？拒绝请求还是排队？使用怎样的处理机制一般两种策略：直接拒绝任务请求；将请求排队，等有空闲线程的时候取出排队的请求继续处理。那如何存储排队的请求呢？这就是今...
java 消费者 生产者 队列_java实现消费者与生产者队列
weixin_42298128的博客
02-12 231
package test;import java.util.Scanner;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class Test{static Scanner sc = new Scanner(System.in);static String line;...
java 消费者 生产者 队列_用Java写一个生产者-消费者队列
weixin_39689377的博客
02-12 168
packageyunche.test.producer;importjava.util.LinkedList;importjava.util.Random;/*** @ClassName: Producer* @Description: 生产者*@author: yunche* @date: 2018/08/26*/public class Producer implementsRunnable{...
java 消费者 生产者 队列_ActiveMQ_Java实现生产者和消费者操作队列
weixin_29018335的博客
02-16 502
一、JMS编码总体规范二、创建Maven工程和引入Maven依赖org.apache.activemqactivemq-all5.15.5org.apache.xbeanxbean-spring4.10三、队列-生产者生产消息实例代码public class JmsProducer {private static final String BROKER_URL = "tcp://192.168.2...
Java基于Queue队列实现生产者消费者模型
WanAkiko.
01-17 566
测试用生产者模型： package domain; import java.util.Queue; /** * 生产者模型 * * @author WanAkiko * */ public class Productor implements Runnable { private Queue<String> queue; // 生产队列 private Integer maxTask; // 最大产量 int i = 1; // 生产计数 public Produc
实现JAVA可伸缩生产者消费者队列服务的详细代码示例
Java自适应多线程可伸缩的生产者消费者队列服务示例代码，是一项重要的系统设计实现，特别适用于云计算和大数据环境。在这个环境下，系统的负载压力经常会出现剧烈变化，数据处理量大且要求系统保持稳定和快速响应。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值