【Java高并发学习】不变模式与2种生产者-消费者模式

最新推荐文章于 2024-04-03 06:30:52 发布
最新推荐文章于 2024-04-03 06:30:52 发布
阅读量318 收藏
点赞数
分类专栏： Java高并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33560169/article/details/78906823
版权

不变模式与2种生产者-消费者模式

概要图，可下载查看。

1.不变模式

一个对象一旦被创建，则它内部状态将永不发生改变，是线程安全的

  1. 当对象创建后，其内部状态和数据不再发生任何变化
  2. 对象需要共享，被多线程频繁访问
Java中实现不变模式：
  1. 去除setter方法以及所有修改自身属性的方法
  2. 将所有属性设置为final private，保证不可修改
  3. 类用final修饰，保证没有子类可以重载修改它的行为
  4. 需要提供一个完整的能创建对象的构造函数
/**
 * 不变模式下的对象类
 * @author wsz
 * @date 2017年12月26日
 */
public final class PCData {

	private final int data;//私用且不可变

	public PCData(int data) {
		super();
		this.data = data;
	}
	
	public PCData(String data) {
		super();
		this.data = Integer.valueOf(data);
	}

	public int getData() {//只提供get方法
		return data;
	}

	@Override
	public String toString() {
		return "PCData [data=" + data + "]";
	}
}

2.不变模式下的生产者-消费者

2.1生产对象（数据）

/**
 * 不变模式下的对象类
 * @author wsz
 * @date 2017年12月26日
 */
public final class PCData {

	private final int data;//私用且不可变

	public PCData(int data) {
		super();
		this.data = data;
	}
	
	public PCData(String data) {
		super();
		this.data = Integer.valueOf(data);
	}

	public int getData() {//只提供get方法
		return data;
	}

	@Override
	public String toString() {
		return "PCData [data=" + data + "]";
	}
}

2.2生产者

import java.util.Random;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 生产者
 * @author wsz
 * @date 2017年12月26日
 */
public class Producer implements Runnable{

	private volatile boolean isRunning = true;//生产开关,满足可见性、有序性（禁止指令重排序），但无法保证（复合操作）原子性
	private BlockingQueue<PCData> queue;		//生产仓库,内存缓冲区;数据共享通道
	private static AtomicInteger count = new AtomicInteger();//生产编号;原子操作
	private static final int SLEEPTIME = 1000;
	
	public Producer(BlockingQueue<PCData> queue) {
		super();
		this.queue = queue;
	}

	@Override
	public void run() {
		PCData data = null;
		Random r = new Random();
		System.out.println("start Producer id="+Thread.currentThread().getId());
		try {
			while(isRunning) {
				Thread.sleep(r.nextInt(SLEEPTIME));
				data = new PCData(count.incrementAndGet());//当前值+1;不变模式,提供完整的构造函数;
				System.out.println(data+" put in queue");
				if(!queue.offer(data, 2, TimeUnit.SECONDS)) {//最多等待2s进行数据放入
					System.out.println("failed put in queue :"+data);
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		}
	}
	
	//停止生产
	public void stop() {
		isRunning = false;
	}
}

2.3消费者

import java.text.MessageFormat;
import java.util.Random;
import java.util.concurrent.BlockingQueue;

/**
 * 消费者
 * @author wsz
 * @date 2017年12月26日
 */
public class Consumer implements Runnable{
	private BlockingQueue<PCData> queue;//数据仓库
	private static final int SLEEPTIME = 1000;
	
	public Consumer(BlockingQueue<PCData> queue) {
		super();
		this.queue = queue;
	}

	@Override
	public void run() {
		System.out.println("start Consumer id="+Thread.currentThread().getId());
		Random r = new Random();
		try{
			while(true) {
				PCData data = queue.take();//Retrieves and removes the head of this queue, waiting if necessary until an element becomes available.
				if(null != data) {
					int re = data.getData()*data.getData();
					System.out.println(MessageFormat.format("{0}*{1}={2}", data.getData(),data.getData(),re));
					Thread.sleep(r.nextInt(SLEEPTIME));
				}
			}
		}catch (InterruptedException e) {
			e.printStackTrace();
			Thread.currentThread().interrupt();
		}
		
	}

}

2.4测试类

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
/**
 * 测试类
 * @author wsz
 * @date 2017年12月26日
 */
public class Test {

	public static void main(String[] args) throws InterruptedException {
		BlockingQueue<PCData>  queue = new LinkedBlockingQueue<PCData>(10);
		//生产者
		Producer p1 = new Producer(queue);
		Producer p2 = new Producer(queue);
		Producer p3 = new Producer(queue);
		//消费者
		Consumer s1 = new Consumer(queue);
		Consumer s2 = new Consumer(queue);
		Consumer s3 = new Consumer(queue);
		//线程池并开启
		ExecutorService service = Executors.newCachedThreadPool();
		service.execute(p1);
		service.execute(p2);
		service.execute(p3);
		service.execute(s1);
		service.execute(s2);
		service.execute(s3);
		//休眠并停止生产
		Thread.sleep(5000);
		p1.stop();
		p2.stop();
		p3.stop();
		Thread.sleep(2000);
		service.shutdown();
	}
}

3.无锁缓存框架Disruptor下的生产者-消费者

使用Disruptor框架需要使用到disruptor.jar包。可在 maven下载disruptor，本次使用的是3.3.2版本。

3.1生产对象（数据）

/**
 * 生产对象
 * @author wsz
 * @date 2017年12月26日
 */
public class PCData {

	private long value;

	public long getValue() {
		return value;
	}

	public void setValue(long value) {
		this.value = value;
	}
}

3.2生产对象工厂

import com.lmax.disruptor.EventFactory;
/**
 * 工厂类,在Disruptor系统初始化时,构造所有缓冲区中的实例对象
 * @author wsz
 * @date 2017年12月26日
 */
public class PCDataFactory implements EventFactory<PCData>{

	@Override
	public PCData newInstance() {
		return new PCData();
	}
}

3.3生产者

import java.nio.ByteBuffer;

import com.lmax.disruptor.RingBuffer;
/**
 * 生产者
 * @author wsz
 * @date 2017年12月26日
 */
public class Producer {

	private final RingBuffer<PCData> ringBuffer;//缓冲区,数据仓库
	public Producer(RingBuffer<PCData> ringBuffer) {
		super();
		this.ringBuffer = ringBuffer;
	}
	
	public void pushData(ByteBuffer bb) {//数据放入缓冲区仓库,参数为ByteBuffer对象,可以包装任何数据
										//此处用来存储long数据。
		long sequence = ringBuffer.next();//得到下一个可用的序列号,
		try {
			PCData event = ringBuffer.get(sequence);//根据序列号获取可用的数据对象
			event.setValue(bb.getLong(0));
		}finally {
			ringBuffer.publish(sequence);//数据发布,发布后消费者才能看见
		}
	}
}

3.4消费者

import com.lmax.disruptor.WorkHandler;
/**
 * 消费者
 * @author wsz
 * @date 2017年12月26日
 */
public class Consumer implements WorkHandler<PCData>{

	//框架回调函数,自动读取数据
	@Override
	public void onEvent(PCData event) throws Exception {
		System.out.println(Thread.currentThread().getId()+":Event:--"+event.getValue()*event.getValue());
	}

}

3.4测试类

import java.nio.ByteBuffer;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import com.lmax.disruptor.BlockingWaitStrategy;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
/**
 * 测试类
 * @author wsz
 * @date 2017年12月26日
 */
public class Test {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws InterruptedException {
		Executor executor = Executors.newCachedThreadPool();
		PCDataFactory factory = new PCDataFactory();
		int bufferSize = 1024;//设置缓冲区大小
		Disruptor<PCData> disruptor = new Disruptor<PCData>(factory, bufferSize, executor, ProducerType.MULTI, new BlockingWaitStrategy());
		disruptor.handleEventsWithWorkerPool(  //设置3个消费者实例,系统会将每一个消费者实例映射到一个线程中
				new Consumer(),
				new Consumer(),
				new Consumer()
				);
		disruptor.start();//启动并初始化disruptor系统
		
		//生产者不断向缓冲区仓库存入数据
		RingBuffer<PCData> ringBuffer = disruptor.getRingBuffer();
		Producer producer = new Producer(ringBuffer);
		ByteBuffer bb = ByteBuffer.allocate(8);
		for(int i =0;true;i++) {
			bb.putLong(0,i);
			producer.pushData(bb);
			Thread.sleep(500);
			System.out.println("add data "+i);
		}
	}
}

4.总结

本文介绍了高并发中使用到的不变模式、两种生产者-消费者模式，其中一种使用Disruptor框架。大致内容可查看图片中总结的知识。
github地址：https://github.com/BeHappyWsz/chart5.git






并发编程专题-5：生产者和消费者模式
你好，开发者
02-17 497
所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据，为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；而消费者只需要从共享数据区中去获取数据，就不再需要关心生产者的行为。 在实现生产者消费者问题时，可以采用三种方式： 使用 Object 的 wa...
Java高并发--BlckingQueue/生产者-消费者模式
weixin_42946624的博客
10-20 331
生产者-消费者模式为多线程间的协作提供了良好解决方案。在C-P模式中，通常有两个线程：若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程负责处理生产者提交的任务。生产者和消费者之间则通过内存共享缓冲区进行通信。 数据共享通道：BlockingQueue BlockingQueue是一个接口，主要的实现有下面这些： 1 ArrayBlockingQueue 基于数组实现...
Java高并发程序-Chapter4 并行模式与算法（第二十五讲）生产者-消费者模式
John,hao的专栏
03-29 209
1.模式定义生产者-消费者模式是一个经典的多线程设计模式。它为多线程间的协作提供了良好的解决方案。在生产者-消费者模式中，通常由两类线程，即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程则负责具体处理生产者提交的任务。生产者和消费者之间则通过共享内存缓冲区进行通信。图5.1 展示了生产者-消费者模式的基本结构。三个生产者线程将任务提交到共享内存缓冲区,消费者线程并不直接...
《Java高并发程序设计》学习 --5.3 并行模式之生产者-消费者模式
sunhaoning的专栏
03-20 523
生产者-消费者是一个经典的多线程设计模式，它为多线程间的协作提供了良好的解决方案。在生产者-消费者模式中，通常有两类线程，即若干个生产者线程和若干个消费者线程。生产者线程负责提交用户请求，消费者线程负责具体处理生产者提交的任务。生产者和消费者之间则通过共享内存缓冲进行通信。  生产者-消费者模式的核心组件是共享内存缓冲区，它作为生产者消费者间的通信桥梁，避免了两者直接通信，从而将生产者和消费者进
Java 高并发编程 -死锁-生产者消费者模式
liuxuxu1991的博客
03-09 207
线程同步：就是在执行代码的时候，同一个资源，被多个线程访问，此时协调这多个线程得访问就是线程同步。 解决比较简单的一种方法是，实用synchronized 同步锁，让下一个线程等待上一个线程执行结束。然后执行，在上synchronized锁得时候，需要注意，这把锁的粒度。 在上synchronized锁得时候经常会碰见的一个问题是，『死锁』 前提：俩个或以上的线程 线程A，整个操作过程中锁...
Java高并发设计模式深度解析：单例、不变与Future
总结来说，这篇文章通过详细介绍设计模式在Java高并发环境下的应用，着重剖析了单例模式的不同实现策略以及生产者消费者模式的工作原理，旨在帮助读者理解和利用这些设计模式提高并发系统的性能和可靠性。...
Java 高并发七：并发设计模型详解
09-01
总结来说，Java的并发设计模型包括了多种策略，如单例模式保证对象的唯一性，不变模式确保对象状态不可变以提升线程安全，Future模式支持异步操作的执行与结果获取，以及生产者消费者模式协调不同线程间的任务执行。...
Java并发设计模式解析与实战
"并发设计模式，Java相关教学资料，由实战Java高并发程序设计讲师葛一鸣提供，内容涵盖设计模式、并发控制等主题。" 在软件开发中，特别是在Java这样的多线程环境中，理解并应用并发设计模式是至关重要的。这些模式...
生产者/消费者模式详解：缓冲区在系统设计中的关键作用
"生产者与消费者模式是一种设计模式，用于解决多线程或并发环境中的数据交换和传输问题。此模式在多个开发领域中有广泛应用，包括但不限于类、函数、线程和进程。" 生产者与消费者模式的核心在于通过一个中介，通常...
Java并发编程（学习笔记）.xmind
06-19
生产者-消费者模式 中断的处理策略 传递InterruptedException 恢复中断，让更高层的代码处理 PriorityQueue（非并发） ConcurrentSkipListMap 替代同步的SortedMap ...
Disruptor的事件处理机制
不甘平庸的人
08-12 1038
单生产者，多消费者模式。消费者1、2不重复消费消息，消费者3、4消费消费者1或2消费过的消息，且独立重复消费。消费者5消费消费者3、4均消费过的消息。单生产者，多消费者模式。消费者1、2独立消费每一条消息，消费者3、4不重复消费消费者1、2均处理过的消息，消费者5消费消费者3或4消费过的消息。消费者之间存在消费顺序，相当于在各个EventHandlerGroup之间进行级联，形成依赖关系。多消费者之间不重复消费，且不同的消费者WorkPool之间存在依赖关系。多生产者，单消费者版本。...
disruptor笔记之五：事件消费实战
最新发布
ehehhahs的博客
04-03 915
import lombok.Setter;import org.springframework.scheduling.concurrent.CustomizableThreadFactory;import javax.annotation.PostConstruct;import java.util.concurrent.CountDownLatch;import java.util.concurrent.atomic.AtomicLong;import java.util.function.Consume
高性能并发框架Disruptor
chengbinbbs的专栏
10-09 521
一、Disruptor是什么 Disruptor是一个开源的并发框架，能够在无锁的情况下实现网络的Queue并发操作。 Disruptor是一个高性能的异步处理框架，或者可以认为是最快的消息框架（轻量级JMS），也可以认为是一个观察者模式的实现，或者事件监听模式的实现。 二、Disruptor核心概念 RingBuffer： 被看做Disruptor最主要组件，然而从3.0开始RingBuf...
Disruptor
一颗旋转的螺丝钉
05-04 2411
参考文章： https://tech.meituan.com/2016/11/18/disruptor.html https://www.cnblogs.com/pku-liuqiang/p/8544700.html 定义Disruptor @Component @Slf4j public class DisruptorUtil { private static int bufferSize ...
disruptor笔记之六：常见场景，java技术基础知识总结
m0_64205415的博客
11-13 416
上述代码有以下几处要注意： 重写父类的init方法，主要是实例化Disruptor的时候，多传入两个参数：ProducerType.MULTI表示生产类型是多生产者，BlockingWaitStrategy是等待策略，之前的代码中咱们没有传此参数时，默认的就是BlockingWaitStrategy init方法中还执行了setProducer2方法，设置成员变量producer2 重写publishWithProducer2方法，调用成员变量producer2发表事件 重写disrup.
disruptor 史上最全之3： 8大使用场景详细图解
架构师尼恩
10-05 4578
本文简绍 disruptor的 8大使用场景
Java多线程-工具篇-BlockingQueue(实现生产者和消费者模式)
li12412414的博客
01-17 5803
前言：      在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 认识BlockingQueue 阻塞队列，顾名思义，首先它是一个队列，而一个队列
Java线程实现生产者消费者模式
swf_shixinshou的博客
06-11 4953
1 什么是生产者消费者模式想一个现实生活中的例子，啤酒商---超市---消费者也就是我们，啤酒商生产了啤酒，然后将啤酒销售给了超市，我们消费之又会到超市将啤酒买回来自己喝，那么啤酒商和消费者之间是什么关系呢？啤酒商不会管消费者消费了多少啤酒，只要是超市中没有了啤酒或者啤酒不足，卖给超市，如果超市啤酒满货，那么就不在生产啤酒，等待超市进货，我们消费者也不必关心啤酒商生产了多少啤酒，只要超市里面有，我...
高并发:阻塞队列 实现生产者-消费者模式
个人专栏
09-12 6975
首先介绍一下非阻塞队列，比如PriorityQueue、LinkedList。在使用非阻塞队列时遇到的问题：不会对当前线程产生阻塞，在面对类似消费者-生产者的模型时，必须额外地实现同步策略以及线程间唤醒策略，这个实现起来非常麻烦。 所以，阻塞队列恰恰不一样，阻塞队列会对当前线程产生阻塞，比如一个线程从一个空的阻塞队列中取元素，此时线程会被阻塞直到阻塞队列中有了元素。当队列中有元素后，被阻塞的线程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值