Disruptor并发＜二＞ _ 秒杀示例

最新推荐文章于 2024-05-25 13:40:42 发布
最新推荐文章于 2024-05-25 13:40:42 发布
阅读量533 收藏 1
点赞数
分类专栏： 并发处理 文章标签： java 缓存 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37543627/article/details/122187040
版权

目录

一、秒杀流程

二、代码示例

1. 依赖及表结构

2. 秒杀下单

3. 本地处理队列

4. 事件对象

5. 消费者 

6. 异常处理消费者

7. 事件生产者

8. 创建Disruptor

三、参考资料

一、秒杀流程

二、代码示例

1. 依赖及表结构

<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.4.4</version>
</dependency>
// 商品库存表
CREATE TABLE `t_goods_stock`  (
  `id` bigint(4) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `goods_id` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '商品ID',
  `stock` bigint(255) NULL DEFAULT NULL COMMENT '库存',
  `price` decimal(8, 2) NULL DEFAULT NULL COMMENT '单价',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;


// 订单表
CREATE TABLE `t_order`  (
  `id` bigint(64) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_id` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户ID',
  `goods_id` bigint(20) NULL DEFAULT NULL COMMENT '商品ID',
  `number` int(11) NULL DEFAULT NULL COMMENT '购买数量',
  `price` decimal(8, 2) NULL DEFAULT NULL COMMENT '单价',
  `total` decimal(8, 2) NULL DEFAULT NULL COMMENT '总价',
  `create_by` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '创建人',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_by` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '修改人',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '修改时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 61686 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

2. 秒杀下单

a. Contoller层

package com.common.instance.test.controller;

import com.common.instance.test.core.Response;
import com.common.instance.test.service.SeckillService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.Random;

/**
 * @description 秒杀活动
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/23 15:47
 **/
@RestController
@RequestMapping("/seckill")
@Api(tags = "秒杀活动")
public class SeckillController {

    @Resource
    private SeckillService seckillService;

    @GetMapping("/isSeckillGoods")
    @ApiOperation("用户是否抢到商品")
    public Response<Boolean> isSeckillGoods(String goodsId){
        // 返回结果
        Boolean isSeckill = false;
        try {
            // 用户是否抢到商品
            // 随机用户
            String userId = String.valueOf(System.currentTimeMillis());
            // 随机商品数量
            Random rand = new Random();
            Integer num = rand.nextInt(10) + 1;

            isSeckill = seckillService.isSeckillGoods(userId, goodsId, num);
        } catch (Exception e) {
            e.printStackTrace();
            return Response.error();
        }
        return Response.success(isSeckill);
    }

}

b. Service层

package com.common.instance.test.service.impl;

import com.common.instance.test.dao.TGoodsStockDao;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.common.instance.test.disruptor.localQueue.RedisQueue;
import com.common.instance.test.entity.TGoodsStock;
import com.common.instance.test.service.SeckillService;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * @description 秒杀活动
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/23 15:49
 **/
@Service
public class SeckillServiceImpl implements SeckillService {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private TGoodsStockDao tGoodsStockDao;

    @Override
    public Boolean isSeckillGoods(String userId, String goodsId, Integer num) {
        // 返回结果
        Boolean result = false;

        // 商品秒杀数量
        Long count = redisTemplate.opsForValue().decrement(RedisQueue.SECKILL_KEY + goodsId, num);
        // 查询商品库存，设置值
        if (Objects.nonNull(count) && count < 0 ) {
            TGoodsStock goodsStock = tGoodsStockDao.selectByPrimaryKey(1L);
            if (Objects.nonNull(goodsStock)) {
                count = goodsStock.getStock() - num;
                redisTemplate.opsForValue().set(RedisQueue.SECKILL_KEY + goodsId, count, 1, TimeUnit.DAYS);
            }
        }
        if (Objects.nonNull(count) && count >= 0) {
            // 创建秒杀商品对象事件
            SeckillGoodsEvent seckillGoodsEvent = new SeckillGoodsEvent();
            seckillGoodsEvent.setUserId(userId);
            seckillGoodsEvent.setGoodsId(goodsId);
            seckillGoodsEvent.setNum(num);

            // 保存到等待队列
            redisTemplate.opsForList().leftPush(RedisQueue.WAIT_QUEUE, seckillGoodsEvent);
            result = true;
        }
        return result;
    }

}

3. 本地处理队列

a. 定义Redis队列

package com.common.instance.test.disruptor.localQueue;

import org.springframework.stereotype.Component;

/**
 * @description Redis队列中
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/23 16:26
 **/
public class RedisQueue {

    // 商品秒伤数量前缀
    public static final String SECKILL_KEY = "SECKILL:GOODS_ID:";
    // 商品秒伤数量锁
    public static final String SECKILL_LOCK = "SECKILL:LOCK:";

    // 等待队列
    public static final String WAIT_QUEUE = "SECKILL:QUEUE:WAIT_QUEUE";
    // 正在处理队列
    public static final String PROCESSING_QUEUE = "SECKILL:QUEUE:PROCESSING_QUEUE";
    // 失败队列
    public static final String FAILED_QUEUE = "SECKILL:QUEUE:FAILED_QUEUE";
    // 镜像队列
    public static final String IMAGE_QUEUE = "SECKILL:QUEUE:IMAGE_QUEUE";

}

b. 本地处理队列

package com.common.instance.test.disruptor.localQueue;

import com.alibaba.fastjson.JSON;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Objects;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * @description 本地事件队列
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/24 17:09
 **/
@Component
public class MyEventQueue {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // 本地事件队列
    private LinkedBlockingQueue<SeckillGoodsEvent> myEventQueue;
    // 队列最大元素数量
    private int capacity = 100000;

    @PostConstruct
    public void create(){
        createEventQueue();
        getWaitQueue();
    }

    private void createEventQueue(){
        myEventQueue = new LinkedBlockingQueue<>();
    }

    private void getWaitQueue(){
        new Thread(new MyThread()).start();
    }

    public LinkedBlockingQueue<SeckillGoodsEvent> getMyEventQueue() {
        return myEventQueue;
    }

    public void setMyEventQueue(LinkedBlockingQueue<SeckillGoodsEvent> myEventQueue) {
        this.myEventQueue = myEventQueue;
    }

    class MyThread implements Runnable {

        @Override
        public void run() {
            while (true) {
                try {
                    // 判定元素数量是否大于容积
                    if (myEventQueue.size() < capacity) {
                        // 等待队列获取秒杀事件
                        Object o = redisTemplate.opsForList().rightPop(RedisQueue.WAIT_QUEUE);
                        if (Objects.nonNull(o)) {
                            String event = JSON.toJSONString(o);
                            SeckillGoodsEvent seckillGoodsEvent = JSON.parseObject(event, SeckillGoodsEvent.class);

                            // 添加到本地队列中
                            myEventQueue.offer(seckillGoodsEvent);
                            // 添加到正在处理队列中
                            redisTemplate.opsForList().leftPush(RedisQueue.PROCESSING_QUEUE, seckillGoodsEvent);
                            // 添加到镜像队列
                            redisTemplate.opsForList().leftPush(RedisQueue.IMAGE_QUEUE, seckillGoodsEvent);
                        } else {
                            Thread.sleep(1 * 1000);
                        }
                    } else {
                        Thread.sleep(1 * 1000);
                    }
//                    LogUtil.info("myEventQueue size: " + myEventQueue.size());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    continue;
                }
            }
        }
    }

}

4. 事件对象

package com.common.instance.test.disruptor.event;

import lombok.Data;

/**
 * @description 秒杀商品事件信息
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/23 15:34
 **/
@Data
public class SeckillGoodsEvent {

    // 用户ID
    private String userId;
    // 商品ID
    private String goodsId;
    // 购买商品数量
    private Integer num;
    // 订单ID
    private Long orderId;

}

5. 消费者 

a. 创建订单消费者

package com.common.instance.test.disruptor.consumer;

import com.common.instance.test.dao.TGoodsStockDao;
import com.common.instance.test.dao.TOrderDao;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.common.instance.test.entity.TGoodsStock;
import com.common.instance.test.entity.TOrder;
import com.lmax.disruptor.EventHandler;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;

/**
 * @description 生成订单
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/24 9:49
 **/
@Component
public class CreateOrderHandler implements EventHandler<SeckillGoodsEvent> {

    @Resource
    private TOrderDao tOrderDao;
    @Resource
    private TGoodsStockDao tGoodsStockDao;

    @Override
    public void onEvent(SeckillGoodsEvent seckillGoodsEvent, long sequence, boolean endOfBatch) throws Exception {
        // 获取商品信息
        TGoodsStock tGoodsStock = tGoodsStockDao.selectByPrimaryKey(1L);

        // 组装订单对象
        TOrder order = createOrder(seckillGoodsEvent, tGoodsStock);

        // 保存订单
        tOrderDao.insert(order);

        // 秒杀活动获取订单ID
        seckillGoodsEvent.setOrderId(order.getId());
    }

    // 组装订单对象
    private TOrder createOrder(SeckillGoodsEvent seckillGoodsEvent, TGoodsStock tGoodsStock){
        TOrder order = new TOrder();

        order.setUserId(seckillGoodsEvent.getUserId());
        order.setGoodsId(Long.valueOf(seckillGoodsEvent.getGoodsId()));
        order.setNumber(seckillGoodsEvent.getNum());
        order.setPrice(tGoodsStock.getPrice());
        // 计算总价
        BigDecimal total = new BigDecimal("0");
        total = total.add(order.getPrice().multiply(new BigDecimal(order.getNumber())));
        order.setTotal(total);
        Date date = new Date();
        order.setCreateBy("admin");
        order.setCreateTime(date);
        order.setUpdateBy("admin");
        order.setUpdateTime(date);

        return order;
    }

}

b. 发送订单kafka消息

package com.common.instance.test.disruptor.consumer;

import com.alibaba.fastjson.JSONObject;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.lmax.disruptor.EventHandler;
import com.log.util.LogUtil;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

import javax.annotation.Resource;

/**
 * @description 发送kafka消息
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/24 11:05
 **/
@Component
public class KafkaHandler implements EventHandler<SeckillGoodsEvent> {

    @Resource
    private KafkaTemplate<String, String> kafkaTemplate;

    public static final String TOPIC_TEST = "SeckillGoodsEvent";

    @Override
    public void onEvent(SeckillGoodsEvent seckillGoodsEvent, long sequence, boolean endOfBatch) throws Exception {
        send(seckillGoodsEvent);
    }

    // 发送kafka消息
    public void send(SeckillGoodsEvent seckillGoodsEvent) {
        String obj2String = JSONObject.toJSONString(seckillGoodsEvent);

        // 发送消息
        ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(TOPIC_TEST, obj2String);
        future.addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                //发送失败的处理
                LogUtil.info(TOPIC_TEST + " - 生产者 发送消息失败：" + throwable.getMessage());
            }

            @Override
            public void onSuccess(SendResult<String, String> stringObjectSendResult) {
                //成功的处理
                LogUtil.info(TOPIC_TEST + " - 生产者 发送消息成功：" + stringObjectSendResult.toString());
            }
        });
    }

}

c. 扣减库存

package com.common.instance.test.disruptor.consumer;

import com.common.instance.test.dao.TGoodsStockDao;
import com.common.instance.test.dao.TOrderDao;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.common.instance.test.entity.TGoodsStock;
import com.common.instance.test.entity.TOrder;
import com.lmax.disruptor.EventHandler;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Objects;

/**
 * @description 扣减库存
 * @author tcm
 * @version 1.0.0
 * @date 2021/12/24 11:08
 **/
@Component
public class ReduceStockHandler implements EventHandler<SeckillGoodsEvent> {

    @Resource
    private TOrderDao tOrderDao;
    @Resource
    private TGoodsStockDao tGoodsStockDao;

    @Override
    public void onEvent(SeckillGoodsEvent event, long sequence, boolean endOfBatch) throws Exception {
        // 获取秒杀订单
        TOrder order = tOrderDao.selectByPrimaryKey(event.getOrderId());
        // 获取商品库存
        TGoodsStock goodsStock = tGoodsStockDao.selectByPrimaryKey(1L);

        if (Objects.nonNull(order) && Objects.nonNull(goodsStock)){
            // 计算库存
            Long stock = goodsStock.getStock() - order.getNumber();
            goodsStock.setStock(stock);
            // 更新库存
            tGoodsStockDao.updateByPrimaryKey(goodsStock);
        }
    }

}

d. 移除正处理队列元素

package com.common.instance.test.disruptor.consumer;

import com.alibaba.fastjson.JSON;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.common.instance.test.disruptor.localQueue.RedisQueue;
import com.lmax.disruptor.*;
import com.log.util.LogUtil;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @description 所有消费处理完，正在处理的秒杀事件移除
 * @author TCM
 * @version 1.0
 * @date 2021/12/25 17:14
 **/
@Component
public class RemoveProcessingQueueHandler implements EventHandler<SeckillGoodsEvent> {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public void onEvent(SeckillGoodsEvent seckillGoodsEvent, long l, boolean b) throws Exception {
        // 事件处理完成后，从正在处理队列中移除
        Object event = redisTemplate.opsForList().rightPop(RedisQueue.PROCESSING_QUEUE);
        LogUtil.info( l +  "removeProcessing: " + JSON.toJSONString(event));
    }

}

6. 异常处理消费者

package com.common.instance.test.disruptor.consumer;

import com.alibaba.fastjson.JSON;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.common.instance.test.disruptor.localQueue.RedisQueue;
import com.lmax.disruptor.ExceptionHandler;
import com.log.util.LogUtil;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @description Disruptor异常捕捉
 * @author TCM
 * @version 1.0
 * @date 2021/12/25 19:39
 **/
@Component
public class MyExceptionHandler implements ExceptionHandler<SeckillGoodsEvent> {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public void handleEventException(Throwable ex, long sequence, SeckillGoodsEvent seckillGoodsEvent) {
        try {
            // 移除正在处理队列事件
            redisTemplate.opsForList().rightPop(RedisQueue.PROCESSING_QUEUE);
            // 添加到失败队列事件
            redisTemplate.opsForList().leftPush(RedisQueue.FAILED_QUEUE, seckillGoodsEvent);
            // 记录处理异常
            LogUtil.error("MyExceptionHandler.handleEventException()", (Exception) ex);
        } catch (Exception e) {
            LogUtil.error("MyExceptionHandler.handleEventException()",
                    "PROCESSING_QUEUE into FAILED_QUEUE failed: " + JSON.toJSONString(seckillGoodsEvent),
                    e);
        }

    }

    @Override
    public void handleOnStartException(Throwable ex) {
        LogUtil.error("MyExceptionHandler.handleOnStartException()", (Exception) ex);
    }

    @Override
    public void handleOnShutdownException(Throwable ex) {
        LogUtil.error("MyExceptionHandler.handleOnShutdownException()", (Exception) ex);
    }

}

7. 事件生产者

package com.common.instance.test.disruptor.publisher;

import com.alibaba.fastjson.JSON;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.common.instance.test.disruptor.localQueue.MyEventQueue;
import com.lmax.disruptor.EventTranslator;
import com.log.util.LogUtil;

import java.util.Objects;

/**
 * @description 将事件发送到RingBuffer
 * @author TCM
 * @version 1.0
 * @date 2021/12/24 22:51
 **/
public class MyEventTranslator implements EventTranslator<SeckillGoodsEvent> {

    // 本地事件队列
    private MyEventQueue myEventQueue;

    public MyEventTranslator(MyEventQueue myEventQueue){
        this.myEventQueue = myEventQueue;
    }

    @Override
    public void translateTo(SeckillGoodsEvent seckillGoodsEvent, long l) {
        // 从本地队列获取事件
        SeckillGoodsEvent event = myEventQueue.getMyEventQueue().poll();
        // 事件属性值赋值
        if (Objects.nonNull(event)){
            seckillGoodsEvent.setUserId(event.getUserId());
            seckillGoodsEvent.setGoodsId(event.getGoodsId());
            seckillGoodsEvent.setNum(event.getNum());
        }

        LogUtil.info(l + " seckillGoodsEvent: " + JSON.toJSONString(seckillGoodsEvent));
    }

}

8. 创建Disruptor

package com.common.instance.test.disruptor;

import com.common.instance.test.disruptor.consumer.*;
import com.common.instance.test.disruptor.event.SeckillGoodsEvent;
import com.common.instance.test.disruptor.localQueue.MyEventQueue;
import com.common.instance.test.disruptor.publisher.MyEventTranslator;
import com.lmax.disruptor.BlockingWaitStrategy;
import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.EventHandlerGroup;
import com.lmax.disruptor.dsl.ProducerType;
import com.log.util.LogUtil;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.concurrent.Executors;

/**
 * @description 创建Disruptor并启动
 * @author TCM
 * @version 1.0
 * @date 2021/12/24 21:20
 **/
@Component
public class SeckillDisruptor {

    // 消费者：所有Handler处理异常记录
    @Resource
    private MyExceptionHandler myExceptionHandler;
    // 消费者：创建订单
    @Resource
    private CreateOrderHandler createOrderHandler;
    // 消费者：发送kafka
    @Resource
    private KafkaHandler kafkaHandler;
    // 消费者：扣减库存
    @Resource
    private ReduceStockHandler reduceStockHandler;
    // 消费者：移除正在处理的秒杀事件
    @Resource
    private RemoveProcessingQueueHandler removeProcessingQueueHandler;

    @Resource
    private MyEventQueue myEventQueue;

    private Disruptor<SeckillGoodsEvent> disruptor;

    @PostConstruct
    public void init(){
        LogUtil.info("SeckillDisruptor init");
        // 创建Disruptor
        disruptor = createDisruptor();
        // 启动
        new Thread(new StartDisruptorThread()).start();
    }

    // 创建Disruptor
    public Disruptor<SeckillGoodsEvent> createDisruptor(){
        // 创建Disruptor
        Disruptor<SeckillGoodsEvent> disruptor = new Disruptor<SeckillGoodsEvent>(
                // 预填充RingBuffer
                new EventFactory(){
                    @Override
                    public Object newInstance() {
                        return new SeckillGoodsEvent();
                    }
                },
                // RingBuffer的大小（必须为2的N次方）
                4096,
                // 线程池处理
                Executors.newWorkStealingPool(256),
                // 生成类型：SINGLE（单生产者）、MULTI（多生产者）
                ProducerType.SINGLE,
                // 等待策略
                new BlockingWaitStrategy());

        // 消费异常处理
        disruptor.setDefaultExceptionHandler(myExceptionHandler);
        // 消费者
        EventHandlerGroup<SeckillGoodsEvent> handlerGroup = disruptor.handleEventsWith(createOrderHandler);
        handlerGroup.then(kafkaHandler, reduceStockHandler);
        handlerGroup.then(removeProcessingQueueHandler);

        return disruptor;
    }

    class StartDisruptorThread implements Runnable {

        @Override
        public void run() {
            disruptor.start();
            while (true) {
                try {
                    // 本地队列没有秒杀事件，休眠50ms
                    if (myEventQueue.getMyEventQueue().isEmpty()) {
//                        LogUtil.info("本地事件队列没有可处理秒杀事件" + Thread.currentThread().getName());
                        Thread.sleep(1 * 50);
                        continue;
                    }

                    // 生产者
                    MyEventTranslator myEventTranslator = new MyEventTranslator(myEventQueue);
                    disruptor.publishEvent(myEventTranslator);
                } catch (Exception e) {
                    e.printStackTrace();
                    continue;
                }
            }
        }

    }

}

三、参考资料

Disruptor 系列（二）使用场景 - 走看看

disruptor模拟高速处理大规模订单类业务场景_congge-CSDN博客

SpringBoot - 并发框架Disruptor使用详解2（多生产者、多消费者、消费者依赖关系）

使用Disruptor完成多个消费者不重复消费消息_tianyaleixiaowu的专栏-CSDN博客_disruptor 多消费者

爱我所爱0505
关注
专栏目录
构建分布式秒杀系统：Disruptor高性能队列
qianlia的博客
04-25 1403
秒杀架构持续优化中，基于自身认知不足之处在所难免，也请大家指正，共同进步。 希望可以把阻塞队列ArrayBlockingQueue这个队列替换成Disruptor，由于之前曾接触过这个东西，听说很不错，正好借此机会整合进来。 简介 LMAX Disruptor是一个高性能的线程间消息库。它源于LMAX对并发性，性能和非阻塞算法的研究，如今构成了Exchange基础架构的核心部分。 Disrupto...
Disruptor购物案例（秒杀）
辉之素狂
12-13 826
一：Disruptor简单说一说 Disruptor 是一个 Java 的并发编程框架，大大的简化了并发程序开发的难度，在性能上也比 Java 本身提供的一些并发包要好。 Disruptor原理：采用了一个数组，循环使用这个数组，从而形成了环。里面有一个序号管理器，使消费者和生产者之前快速正确地传输数据。RingBuffer中每个数据的序号，用于跟踪ringbuffer中任务的变化和消费者的消...
Disruptor示例
10-19
Martin Fowler在自己网站上写了一篇LMAX架构的文章，在文章中他介绍了LMAX是一种新型零售金融交易平台，它能够以很低的延迟产生大量交易。这个系统是建立在JVM平台上，其核心是一个业务逻辑处理器，它能够在一个线程里每秒处理6百万订单。业务逻辑处理器完全是运行在内存中，使用事件源驱动方式。业务逻辑处理器的核心是Disruptor。 Disruptor它是一个开源的并发框架，并获得2011 Duke’s 程序框架创新奖，能够在无锁的情况下实现网络的Queue并发操作。 Disruptor是一个高性能的异步处理框架，或者可以认为是最快的消息框架（轻量的JMS），也可以认为是一个观察者模式的实现，或者事件监听模式的实现。
从构建分布式秒杀系统聊聊Disruptor高性能队列
weixin_30478619的博客
05-24 257
前言 秒杀架构持续优化中，基于自身认知不足之处在所难免，也请大家指正，共同进步。文章标题来自码友的建议，希望可以把阻塞队列ArrayBlockingQueue这个队列替换成Disruptor，由于之前曾接触过这个东西，听说很不错，正好借此机会整合进来。 简介 LMAX Disruptor是一个高性能的线程间消息库。它源于LMAX对并发性，性能和非阻塞算法的研究，如今构成了Exchange基础架构...
Disruptor 简例
何星平的博客
11-30 273
定义事件 /** * 定义event事件：通过Disruptor进行交换的数据类型 * @author hxp * @create 2020-11-17 17:02 */ public class StringEvent { private String value; // 放一个字符串数据 public String getValue() { return value; } public void setValue(String value)
Disruptor应用实例
05-03
NULL 博文链接：https://bijian1013.iteye.com/blog/2435671
Disruptor实际应用示例
sunquan291的专栏
09-22 2024
Disruptor实际应用示例简介告警处理需求告警信息处理器调度DisruptorApplicationEventHandlerProcessClassUtil测试AbstractEventHandlerODL实现 简介 Disruptor它是一个开源的并发框架，并获得2011 Duke’s 程序框架创新奖，能够在无锁的情况下实现Queue并发操作。同学们代码中是否会使用到BlockingQueu...
disruptor-3.3.8.jar
10-18
Error: java.lang.NoSuchMethodError: com.lmax.disruptor.dsl.Disruptor.<init>(Lcom/lmax/disruptor/EventFactory;ILjava/util/concurrent/ThreadFactory;Lcom/lmax/disruptor/dsl/ProducerType;Lcom/lmax/...
翻译代码 <route> <from uri="disruptor:delay-and-dispatch-1686019368607?concurrentConsumers=4"/> <setHeader name="upstreamDataSourceIds"> <groovy>[28]</groovy> </setHeader> <setHeader name="upstreamLabelIds"> <groovy>[]</groovy> </setHeader> <to uri="cdp:label/realtime/kvReady?labelId=21&cacheInterval=180"/> <choice> <when> <groovy>true && headers.kvReady</groovy> <to uri="direct:kv-compute-1686019368607"/> </when> <otherwise> <to uri="direct:clickhouse-compute-1686019368607"/> </otherwise> </choice> </route>
06-07
这是一个 Apache Camel 的路由配置，表示当接收到消息时，从 "disruptor:delay-and-dispatch-1686019368607?concurrentConsumers=4" 这个组件中获取数据，并设置消息头部的 "upstreamDataSourceIds" 和 ...
<from uri="disruptor:write-to-tendis-${dataSourceId}?concurrentConsumers=8" /> <setHeader name="CamelRedis.Command"> <constant>ZADD</constant> </setHeader> <setHeader name="CamelRedis.Key"> <groovy>"datasource:behavior:${dataSourceId}:$headers.eventId:$body.${baseIdColumn}".toString()</groovy> </setHeader> <setHeader name="CamelRedis.Score"> <groovy>body.${timeColumn}</groovy> </setHeader>翻译代码
06-13
这里使用了disruptor组件，并发消费者数量为8。 ``` <from uri="disruptor:write-to-tendis-${dataSourceId}?concurrentConsumers=8" /> ``` 2. 设置Redis命令为ZADD，表示要向有序集合中添加一个或多个元素。 ``...
翻译代码<filter> <groovy>import org.joda.time.DateTime;body.timestamp >= new DateTime().withMillisOfDay(0).getMillis() && ((body.resourceType == 1 && body.resourceId in [28]) || (body.resourceType == 2 && body.resourceId in []))</groovy> <to uri="disruptor:delay-and-dispatch-1686019368607"/> </filter> </route> <route> <from uri="disruptor:filter-by-specified-id-1686019368607"/> <unmarshal> <json library="Jackson"/> </unmarshal> <filter> <groovy>(body.resourceType == 2 && body.resourceId == 21)</groovy> <to uri="disruptor:delay-and-dispatch-1686019368607"/> </filter> </route>
06-07
第二个路由从 Disruptor 组件（filter-by-specified-id-1686019368607）中读取消息，并使用 Groovy 代码进行过滤。其中，它判断消息的资源类型是否为 2，且资源 ID 是否为 21。如果满足条件，则将消息发送到 ...
java后端源码部署-artemis-disruptor-miaosha:没有redis也能够支撑"小米在印度把亚马逊搞挂了"事件的秒杀解决方
06-05
java后端源码部署 artemis-disruptor-miaosha 没有redis也能够支撑的秒杀解决方案。 小米在印度打破了多项记录： 4分钟内卖出了超过250,000台。 ---OPS:1042次抢购/S 成为最快的手机抢购活动。 抢购前我们收到了100万“到货提醒”。 亚马逊每分钟收到超过500万个点击。 亚马逊在这个期间每秒收到1500个订单（这是印度电商公司所有销售中最高的）。 ---OPS：1500次下单请求/S 性能表现 先说一下性能表现吧，因为大家对这个比较感兴趣。 硬件环境(Tomcat、Artemis、Jmeter、Oracle，backend都在这台电脑上)： MacBook Pro (Retina, 15-inch, Mid 2014) 2.2 GHz Intel Core i7 16 GB 1600 MHz DDR3 512G SSD 软件环境： java version "1.8.0_131" Artemis 1.5.4 Oracle XE 11g (Docker) Tomcat 8.5.14 (1个) 相关配置见 测试Jmeter脚本见： 300线程
Disruptor并发框架中文参考文档
11-17
### Disruptor并发框架知识点详解 #### 一、Disruptor简介及原理 **Disruptor** 是一款高性能、低延迟的并发框架，它通过无锁设计实现了高效的队列操作，从而大大提升了多线程环境下的性能表现。该框架于2011年...
disruptor3.x 简单例子
小草的胡言乱语
05-03 293
这个是最新的 disruptor3的例子....来自官方代码稍微简化后的     package io.grass.core.collect; import static com.lmax.disruptor.RingBuffer.createSingleProducer; import java.util.concurrent.CountDownLatch; import...
disruptor框架java实例_java架构《并发编程框架篇 __Disruptor》
weixin_34489135的博客
02-27 287
Disruptor入门获得Disruptor可以通过Maven或者下载jar来安装Disruptor。只要把对应的jar放在Java classpath就可以了。基本的事件生产和消费我们从一个简单的例子开始学习Disruptor：生产者传递一个long类型的值给消费者，而消费者消费这个数据的方式仅仅是把它打印出来。首先声明一个Event来包含需要传递的数据：1 public classLongEv...
Disruptor高性能队列设计以及如何从0到1实现一个秒杀系统案例
chiyueluo1783的博客
05-30 227
https://gitee.com/52itstyle/spring-boot-seckill https://blog.csdn.net/iie_libi/article/details/55511588 ...
Disruptor（二）基础开发
汪涛的专栏
07-29 254
1、获取Disruptor Maven仓库 https://search.maven.org/search?q=g:com.lmax%20AND%20a:disruptor 源码 https://github.com/LMAX-Exchange/disruptor 2、一个简单的事件生产者和消费者示例 首先创建一个事件数据类型： 创建一个事件工厂，使Disruptor可以用来生成RingBuffer的预分配条目： 创建一个事件消费者： 在本例中，我们假设这个..
高效秒杀系统：artemis-disruptor-miaosha
gitblog_00015的博客
05-19 434
高效秒杀系统：artemis-disruptor-miaosha artemis-disruptor-miaosha没有redis也能够支撑"小米在印度把亚马逊搞挂了"事件的秒杀解决方案项目地址:https://gitcode.com/gh_mirrors/ar/artemis-disruptor-miaosha 当面对大规模并发请求的挑战时，如小米在印度的秒杀事件，传统的技术架构可能会显得力不...
秒级达百万高并发框架Disruptor
最新发布
茂盛博客
05-25 635
1、起源 Disruptor最初由lmax.com开发，2010年在Qcon公开发表，并于2011年开源，企业应用软件专家Martin Fowler专门撰写长文介绍，同年它还获得了Oracle官方的Duke大奖。其官网定义为：“High Performance Inter-Thread Messaging Library”，即：线程间的高性能消息框架。其实JDK已经为我们提供了很多开箱即用的线程间通信的消息队列，如：ArrayBlockingQueue、LinkedBlockingQueue、Conc
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值