高吞吐高性能异步消息处理系统（二）

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

=========================生产者线程从redis queue中读取消息，加入ringBuffer=================

=========================消息者线程从ringBuffer中消费消息，交由具体的eventHandler处理=========

事件类

package com.qb.loan.disruptor;

public class Event {
	//事件类型
	private String eventType;
	//事件key
	private String key;
	//事件value
	private Object value;
	public String getEventType() {
		return eventType;
	}
	public void setEventType(String type) {
		this.eventType = type;
	}
	public String getKey() {
		return key;
	}
	public void setKey(String key) {
		this.key = key;
	}
	public Object getValue() {
		return value;
	}
	public void setValue(Object value) {
		this.value = value;
	}
	@Override
	public String toString() {
		return "Event [eventType=" + eventType + ", key=" + key + ", value="
				+ value + "]";
	}
	
	
}

事件工厂类

package com.qb.loan.disruptor;

import com.lmax.disruptor.EventFactory;
/**
 * 事件工厂
 * @author qianll
 *
 */
public class DefaultEventFactory implements EventFactory<Event>{

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

}

disruptor核心组件类

package com.qb.loan.disruptor;

import java.lang.Thread.UncaughtExceptionHandler;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.lmax.disruptor.BlockingWaitStrategy;
import com.lmax.disruptor.EventTranslator;
import com.lmax.disruptor.ExceptionHandler;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.WorkHandler;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
import com.qb.loan.disruptor.exception.ConsumerFailException;
import com.qb.loan.disruptor.exception.ConsumerSuccessException;
import com.zrj.platform.base.log.AppLogger;

/**
 * disruptor核心组件类
 * @author qianll
 *
 */
@Service
@Lazy(false)
public class DisruptorInitialization implements ApplicationContextAware{
	
	protected AppLogger logger = new AppLogger(DisruptorInitialization.class);
	
	@Resource
	private EventQueue eventQueue;
	
	private Map<String,EventHandler> eventHandlerMap;
	
	private Disruptor<Event> disruptor;
	
	private ApplicationContext applicationContext;
	
	private RingBuffer<Event> ringBuffer;
	
	private List<EventPublishThread> list = new ArrayList<EventPublishThread>();

	@PostConstruct
	public void init(){ 
		eventHandlerMap = applicationContext.getBeansOfType(EventHandler.class);
		logger.doInfo("获取事件处理机，个数为:", eventHandlerMap.size());
		disruptor = new Disruptor<Event>(new DefaultEventFactory(),1024,Executors.newFixedThreadPool(eventHandlerMap.size()), ProducerType.MULTI,new BlockingWaitStrategy());
		//异常处理
		disruptor.handleExceptionsWith(new ExceptionHandler(){

			@Override
			public void handleEventException(Throwable ex, long sequence,
					Object event) {				
				logger.doError(event.toString(),ex);
				if(ex instanceof ConsumerFailException){
					logger.doError("",ex);
					//TODO 记录到NO-SQL数据库中 判断是否需求重新消费
				}
				if(ex instanceof ConsumerSuccessException){
					logger.doError("",ex);
					//TODO 记录到NO-SQL数据库中 判断是否需求从执行队列中删除
				}
			}

			@Override
			public void handleOnStartException(Throwable ex) {
				logger.doError("",ex);
			}

			@Override
			public void handleOnShutdownException(Throwable ex) {
				logger.doError("",ex);
			}
			
		});
		//消费者
		@SuppressWarnings("unchecked")
		WorkHandler<Event>[] array = new WorkHandler[eventHandlerMap.size()];
		for(int i=0; i<eventHandlerMap.size();i++){
			array[i] = new WorkHandler<Event>(){
				@Override
				public void onEvent(Event event) throws Exception {
					String type = event.getEventType();
					eventHandlerMap.get(type).onEvent(event);
				}				
			};
		}
		disruptor.handleEventsWithWorkerPool(array);
		ringBuffer = disruptor.start();
		//生产者
		for(String eventType : eventHandlerMap.keySet()){
			EventPublishThread thread = new EventPublishThread(ringBuffer,eventQueue,eventType);
			thread.setUncaughtExceptionHandler(new UncaughtExceptionHandler(){
				@Override
				public void uncaughtException(Thread t, Throwable e) {
					logger.doError(t.getName(),e);					
				}				
			});
			thread.start();
			logger.doInfo("生产者线程启动！", null);
			list.add(thread);
		}
	}
	
	@PreDestroy
	public void destroy(){
		for(EventPublishThread thread:list){
			thread.setRunning(false);
		}
		if(disruptor != null){
			disruptor.shutdown();
		}
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		this.applicationContext = applicationContext;
	}
	
	private class EventPublishThread extends Thread{

		private RingBuffer<Event> ringBuffer;
		
		private EventQueue eventQueue;
		
		private String eventType;
		
		private boolean running = true;
		
		private EventPublishThread(RingBuffer<Event> ringBuffer,EventQueue eventQueue,String eventType){
			this.ringBuffer = ringBuffer;
			this.eventQueue = eventQueue;
			this.eventType = eventType;
		}
		
		@Override
		public void run() {
			LoadingCache<Long,AtomicInteger> counter =
					CacheBuilder.newBuilder()
					.expireAfterAccess(2,TimeUnit.MINUTES)
					.build(new CacheLoader<Long,AtomicInteger>(){
						@Override
						public AtomicInteger load(Long minute) throws Exception {
							return new AtomicInteger(0);
						}						
					});
			while(running){
				String failKey = null;
				try{
					final String key = eventQueue.rpop(eventType);
//					logger.doInfo(eventType+"从队列中获取元素:", key);
					if(key != null){
						failKey = key;
						eventQueue.lpush(eventType+"_processing", key);
						ringBuffer.publishEvent(new EventTranslator<Event>(){
							@Override
							public void translateTo(Event event,long sequence) {
								event.setEventType(eventType);
								event.setKey(key);
							}							
						});
//						logger.doInfo(eventType+"向disruptor发布事件:", key);
						
					}else{
						//释放cpu，避免长期占用cpu，导致负载增加
						Thread.sleep(2000l);
					}
				}catch(Exception e){
					if(failKey != null){
						//TODO 记录到NO-SQL数据库中 判断是否需求重新消费
					}
					logger.doError(eventType,e);
					//限流处理，防止日志雪崩
					long currentMinutes = System.currentTimeMillis()/1000/60;
					try{
						//TODO微信报警
						if(counter.get(currentMinutes).incrementAndGet() > 10){
							logger.doError(eventType+"生产消息错误超标!");
							Thread.sleep(1000*60*5);
						}
					}catch(Exception ex){
						logger.doError(eventType,ex);
					}
				}
			}			
		}

		public void setRunning(boolean running) {
			this.running = running;
		}

		
	}
	
}

EventHandler接口类

package com.qb.loan.disruptor;
/**
 * 事件处理器
 * @author qianll
 *
 */
public interface EventHandler {
	void onEvent(Event event);
}

抽象事件处理类

package com.qb.loan.disruptor;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import javax.annotation.Resource;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.qb.loan.disruptor.exception.ConsumerFailException;
import com.qb.loan.disruptor.exception.ConsumerSuccessException;
import com.zrj.platform.base.log.AppLogger;

public abstract class AbstractEventHandler implements EventHandler {
	
	@Resource
	protected EventQueue eventQueue;
	
	private AppLogger logger = new AppLogger(AbstractEventHandler.class);
	
	LoadingCache<Long,AtomicInteger> counter =
			CacheBuilder.newBuilder()
			.expireAfterAccess(2,TimeUnit.MINUTES)
			.build(new CacheLoader<Long,AtomicInteger>(){
				@Override
				public AtomicInteger load(Long minute) throws Exception {
					return new AtomicInteger(0);
				}						
			});

	@Override
	public void onEvent(Event event) {
		try{
			processEvent(event);
		}catch(Exception e){
			logger.doError("",e);
			long currentMinutes = System.currentTimeMillis()/1000/60;
			try{
				if(counter.get(currentMinutes).incrementAndGet() > 10){
					logger.doError("消费事件错误次数超标！");
					//TODO 微信报警
				}
			}catch(Exception ex){
				ex.printStackTrace();
			}
			fail(event,e);
		}
		try{
			success(event);
		}catch(Exception e){
			throw new ConsumerSuccessException(e);
		}
	}
	
	abstract void processEvent(Event event);
	
	protected void success(Event event){
		long l = eventQueue.lrem(event.getEventType()+"_processing", 1, event.getKey());
//		logger.doInfo(event.getEventType()+"消息成功："+event.getKey(),null);
	}
	
	protected void fail(Event event,Exception e){
		throw new ConsumerFailException(e);
	}

}

事件处理实现类

package com.qb.loan.disruptor;

import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zrj.platform.base.log.AppLogger;

/**
 * 还款计划事件处理器
 * @author qianll
 *
 */
@Service("payplan")
public class PayplanEventHandler extends AbstractEventHandler {

	private AppLogger logger = new AppLogger(PayplanEventHandler.class);
	
	private AtomicInteger count = new AtomicInteger(0);
	
	@Override
	void processEvent(Event event) {
		// TODO 根据事件key查询相关信息
		// TODO ES中重建索引 or 其他触发动作
		if(count.incrementAndGet()%1000 ==0){
			logger.doInfo(event.getEventType()+"已消费"+count.get()+"个消息。", new Date());
		}
		if(count.get()>10000000){
			count.set(0);
		}
	}

}

事件处理实现类

package com.qb.loan.disruptor;

import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.stereotype.Service;

import com.zrj.platform.base.log.AppLogger;

/**
 * 代扣事件处理器
 * @author qianll
 *
 */
@Service("withhold")
public class WithholdEventHandler extends AbstractEventHandler {
	
	private AppLogger logger = new AppLogger(WithholdEventHandler.class);
	
	private AtomicInteger count = new AtomicInteger(0);

	@Override
	void processEvent(Event event) {
		// TODO 根据事件key查询相关信息
		// TODO ES中重建索引 or 其他触发动作
		if(count.incrementAndGet()%1000 ==0){
			logger.doInfo(event.getEventType()+"已消费"+count.get()+"个消息。", new Date());
		}
		if(count.get()>10000000){
			count.set(0);
		}
	}



}

redis处理类

package com.qb.loan.disruptor;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.qianbao.redis.service.RedisClient;
/**
 * 封装了对redis队列的访问
 * @author qianll
 *
 */
@Service
public class EventQueue {

	 @Resource
	 private RedisClient redisClient;
	 
	 @Value("${redis.client.namespace}")
	 private String namespace;
	 
	 /**
	  * 弹出列表中的第一个元素，无则返回null
	  * @param queueName
	  * @return
	  */
	 public String rpop(String queueName){
		String result = null;
		try {
			result = redisClient.rpop(namespace, queueName);
			if(result != null && result.equals("nil")){
				result = null;
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		} 
		return result;
	 }
	 /**
	  * 从列表头插入元素，返回插入后列表中的元素数
	  * @param queueName
	  * @param elements
	  * @return
	  */
	 public Long lpush(String queueName,String... elements){
		 Long result = 0l;
		 try {
			result = redisClient.lpush(namespace, queueName, elements);
		} catch (Exception e) {
			throw new RuntimeException(e);
		} 
		 return result;
	 }
	 /**
	  * 从列表头开始删除前count个value值
	  * @param key
	  * @param count
	  * @param value
	  * @return 删除的元素个数
	  */
	 public Long lrem(String key,long count,String value){
		 Long result = 0l;
		 try{
			 result = redisClient.lrem(namespace, key, count, value);
		 }catch (Exception e) {
				throw new RuntimeException(e);
		 }
		 return result;
	 }
	 /**
	  * 删除缓存key
	  * @param key
	  * @return
	  */
	 public Long del(String key){
		 Long result = 0l;
		 try{
			 result = redisClient.del(namespace, key);
		 }catch (Exception e) {
				throw new RuntimeException(e);
		 }
		 return result;
	 }
}

异常处理类

package com.qb.loan.disruptor.exception;

public class ConsumerFailException extends RuntimeException{
	
	private static final long serialVersionUID = 1L;
	
	public ConsumerFailException(){}

	public ConsumerFailException(String message){
		super(message);
	}
	
	public ConsumerFailException(Exception ex){
		super(ex.getMessage());
	}
}

package com.qb.loan.disruptor.exception;

public class ConsumerSuccessException extends RuntimeException{

	private static final long serialVersionUID = 1L;
	
	public ConsumerSuccessException(String message){
		super(message);
	}
	
	public ConsumerSuccessException(Exception ex){
		super(ex.getMessage());
	}

}


qian_348840260
关注
专栏目录
Disruptor框架中生产者、消费者的各种复杂依赖场景下的使用总结
weixin_30645617的博客
03-11 1047
版权声明：原创作品，谢绝转载！否则将追究法律责任。 Disruptor是一个优秀的并发框架，可以实现单个或多个生产者生产消息，单个或多个消费者消息，且消费者之间可以存在消费消息的依赖关系。网上其他博客往往仅针对框架的一部分使用示例进行了介绍，对于某些场景下介绍并不完全：如多生产者间复杂的依赖关系的使用编码。 本文尽可能对Disruptor的所有使用场景进行总结，如有不全之处欢迎指出，请谅解。...
disruptor笔记之六：常见场景，java技术基础知识总结
m0_64205415的博客
11-13 416
上述代码有以下几处要注意： 重写父类的init方法，主要是实例化Disruptor的时候，多传入两个参数：ProducerType.MULTI表示生产类型是多生产者，BlockingWaitStrategy是等待策略，之前的代码中咱们没有传此参数时，默认的就是BlockingWaitStrategy init方法中还执行了setProducer2方法，设置成员变量producer2 重写publishWithProducer2方法，调用成员变量producer2发表事件 重写disrup.
高吞吐高性能异步消息处理系统（一）
八荒六合唯我独尊
06-11 401
依赖的jar包 &lt;dependency&gt; &lt;groupId&gt;com.lmax&lt;/groupId&gt; &lt;artifactId&gt;disruptor&lt;/artifactId&gt; &lt;version&gt;3.2.0&lt;/version&gt; &lt;/dependency&gt;
Disruptor的事件处理机制
不甘平庸的人
08-12 1034
单生产者，多消费者模式。消费者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...
Springboot实现高吞吐量异步处理详解(适用于高并发场景)
08-25
使用Springboot异步处理架构可以实现高吞吐量异步处理，并且可以提高服务器的性能和可扩展性。 技术要点3: Maven依赖配置 为了使用Springboot框架实现高吞吐量异步处理，需要在Maven项目中添加相应的依赖配置。...
java开发一种高吞吐量的分布式发布订阅消息系统项目源码.zip
10-28
其中，Kafka是一款广泛使用的开源分布式发布订阅消息系统，以其高性能、高吞吐量、持久化和可扩展性等特点深受开发者喜爱。本文将围绕Java开发的高吞吐量分布式发布订阅消息系统项目，深入解析Kafka的核心概念和关键...
电商异步消息系统的实践
04-04
在电商领域，异步消息系统是构建高可用、高性能、可扩展系统的关键技术之一。它通过解耦服务间通信，提升了系统的并发处理能力和响应速度，同时也增强了系统的容错性。以下是对这一主题的详细探讨： 一、异步消息...
.net使用的高性能大吞吐量socket
07-20
总的来说，通过合理地利用.NET的Socket类和I/O完成端口，开发者可以构建出能够处理大量并发连接、具备高性能和大吞吐量的网络应用。这在高并发场景，如服务器开发、实时数据交换等应用中，显得尤为重要。同时，测试...
springboot高并发下提高吞吐量的实现
08-25
本文将详细介绍如何使用多线程技术来提高 SpringBoot 应用程序的吞吐量，从而解决高并发场景下的性能问题。 知识点 1: 高并发下的性能问题 在高并发场景下，SpringBoot 应用程序的性能问题变得非常突出。如果不...
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 史上最全之3： 8大使用场景详细图解
架构师尼恩
10-05 4576
本文简绍 disruptor的 8大使用场景
利用Redis实现异步消息队列优化系统性能 （Redis高级应用）
热门推荐
little prince，blue coder
08-18 1万+
写在前面 今天把之前在项目中使用 Redis 做异步消息队列的使用经验总结一下。首先明确使用目的，因为项目中，我们进行某个操作后可能后续会有一系列的其他耗时操作，但是我们不希望将主线程阻塞在此过程中，这时便可将其他操作异步化。举个栗子，当你给这篇博客点赞或评论的时候，博客系统会保存你的点赞评论信息，同时将此操作封装为事件发给异步消息队列，处理过程中会给我发个私信告诉我谁评论了我，或谁给我点了赞，...
如何写出可测试的 Go 代码
kevin_tech的博客，微信搜「网管叨bi叨」
05-11 312
这个系列中已经介绍了很多 Go 单元测试的技能和工具，在这一篇中我们不再介绍编写单元测试的工具而是专注于如何编写可测试的代码。编写可测试的代码编写可测试的代码可能比编写单元测试本身更加重要，可测试的代码简单来说就是指我们可以很容易的为其编写单元测试代码。编写单元测试的过程也是一个不断思考的过程，思考我们的代码是否正确的被设计和实现。接下来，我们将通过几个简单示例来介绍如何...
鲁:：鲁ck的日志记录。 C ++的低延迟，高吞吐量，异步日志记录库
01-28
实际的消息格式化和写入是由一个单独的线程异步执行的。 这消除或隐藏了一些成本： 在调用站点没有过渡到内核。 内核是一个容易被忽略但重要的成本，这不仅是因为转换要花费时间，而且还因为它会污染CPU缓存。 ...
详解Spring MVC的异步模式（高性能的关键）
08-31
在本文中，我们将深入探讨Spring MVC的异步模式，这是实现高性能Web应用程序的关键技术。首先，我们需要理解异步模式的基本概念及其与同步模式的区别。 同步模式是标准的Web服务器处理请求的方式，即客户端发送请求...
提高系统性能的2个常用手段---缓存和异步
逍遥飞鹤的专栏
09-14 6121
缓存 缓存  1.1 缓存刷新机制，缓存刷新是指什么时候把数据库中的数据加载到缓存  （1） 定期刷新；  （2） 缓存命中失败时刷新；  1.2 在有缓存时的数据写入方式：  （1） 同步写入，即缓存和数据库同时被写入，即在应用层进行双写操作，这种方式可以有效保证缓存和DB中数据的一致性，由于这种方式即要更新缓存同时还要更改数据库，其访问效率相对较低，适合读多写少的场景；
高可靠高性能的消息队列怎么去实现？
360linker
09-26 920
我们看看RPC调用的场景。服务A调用如图所示服务。在正常情况下，一般都不会有问题。但是在以下情况，服务A调用会遇到问题。 问题一：如果有流量高峰，服务B响应超时，会发生什么情况？ 整个RPC调用链路都会受到影响，甚至发生雪崩。 问题二：服务A逻辑复杂，逻辑耦合严重，怎么做拆分？ 把一些调用链路中可以异步调用的逻辑调整为消费MQ消息。 问题三：RPC调用，jar依赖问题？服务B升级，调...
EventBus监听模式实例
厚积薄发
03-19 1607
目录 先定义一个注解 自定义一个EventBus EventBus启动配置 定义事件类型实体, 和对应的监听操作 发布事件 小结 先定义一个注解 /** * eventbus开启注解，只有开启了该注解的类的方法才可用Subscribe注解监听event事件 * @author zsd */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) @Component public @int
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值