编程语言disruptor笔记之三：环形队列的基础操作(不用Disruptor类)

编程语言disruptor笔记之三：环形队列的基础操作(不用Disruptor类)

欢迎访问我的GitHub

https://github.com/zq2599/blog_demos

内容：所有原创文章分类汇总及配套源码，涉及Java、Docker、Kubernetes、DevOPS等；

《disruptor笔记》系列链接

1. 快速入门
2. Disruptor类分析
3. 环形队列的基础操作(不用Disruptor类)
4. 事件消费知识点小结
5. 事件消费实战
6. 常见场景
7. 等待策略
8. 知识点补充(终篇)

本篇概览

• 本文是《disruptor笔记》系列的第三篇，主要任务是编码实现消息生产和消费，与《disruptor笔记之一：快速入门》不同的是，本次开发不使用Disruptor类，和Ring Buffer(环形队列)相关的操作都是自己写代码实现；
• 这种脱离Disruptor类操作Ring Buffer的做法，不适合用在生产环境，但在学习Disruptor的过程中，这是种高效的学习手段，经过本篇实战后，在今后使用Disruptor时，您在开发、调试、优化等各种场景下都能更加得心应手；
• 简单的消息生产消费已不能满足咱们的学习热情，今天的实战要挑战以下三个场景：

1. 100个事件，单个消费者消费；
2. 100个事件，三个消费者，每个都独自消费这个100个事件；
3. 100个事件，三个消费者共同消费这个100个事件；

前文回顾

为了完成本篇的实战，前文《disruptor笔记之二：Disruptor类分析》已做了充分的研究分析，建议观看，这里简单回顾以下Disruptor类的几个核心功能，这也是咱们编码时要实现的：

1. 创建环形队列（RingBuffer对象）
2. 创建SequenceBarrier对象，用于接收ringBuffer中的可消费事件
3. 创建BatchEventProcessor，负责消费事件
4. 绑定BatchEventProcessor对象的异常处理类
5. 调用ringBuffer.addGatingSequences，将消费者的Sequence传给ringBuffer
6. 启动独立线程，用来执行消费事件的业务逻辑

• 理论分析已经完成，接下来开始编码；

源码下载

• 本篇实战中的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：

名称	链接	备注
项目主页	GitHub - zq2599/blog_demos: CSDN博客专家程序员欣宸的github，这里有五百多篇原创文章的详细分类和汇总，以及对应的源码，内容涉及Java、Docker、Kubernetes、DevOPS等方面	该项目在GitHub上的主页
git仓库地址(https)	https://github.com/zq2599/blog_demos.git	该项目源码的仓库地址，https协议
git仓库地址(ssh)	git@github.com:zq2599/blog_demos.git	该项目源码的仓库地址，ssh协议

• 这个git项目中有多个文件夹，本次实战的源码在disruptor-tutorials文件夹下，如下图红框所示：

• disruptor-tutorials是个父工程，里面有多个module，本篇实战的module是low-level-operate，如下图红框所示：

开发

• 进入编码阶段，今天的任务是挑战以下三个场景：

1. 100个事件，单个消费者消费；
2. 100个事件，三个消费者，每个都独自消费这个100个事件；
3. 100个事件，三个消费者共同消费这个100个事件；

• 咱们先把工程建好，然后编写公共代码，例如事件定义、事件工厂等，最后才是每个场景的开发；
• 在父工程disruptor-tutorials新增名为low-level-operate的module，其build.gradle如下：

plugins {
    id 'org.springframework.boot'
}

dependencies {
    implementation 'org.projectlombok:lombok'
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'com.lmax:disruptor'

    testImplementation('org.springframework.boot:spring-boot-starter-test')
}

• 然后是springboot启动类：

package com.bolingcavalry;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class LowLevelOperateApplication {
	public static void main(String[] args) {
		SpringApplication.run(LowLevelOperateApplication.class, args);
	}
}

• 事件类，这是事件的定义：

package com.bolingcavalry.service;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@Data
@ToString
@NoArgsConstructor
public class StringEvent {
    private String value;
}

• 事件工厂，定义如何在内存中创建事件对象：

package com.bolingcavalry.service;

import com.lmax.disruptor.EventFactory;

public class StringEventFactory implements EventFactory {
    @Override
    public StringEvent newInstance() {
        return new StringEvent();
    }
}

• 事件生产类，定义如何将业务逻辑的事件转为disruptor事件发布到环形队列，用于消费：

package com.bolingcavalry.service;

import com.lmax.disruptor.RingBuffer;

public class StringEventProducer {

    // 存储数据的环形队列
    private final RingBuffer ringBuffer;

    public StringEventProducer(RingBuffer ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    public void onData(String content) {

        // ringBuffer是个队列，其next方法返回的是下最后一条记录之后的位置，这是个可用位置
        long sequence = ringBuffer.next();

        try {
            // sequence位置取出的事件是空事件
            StringEvent stringEvent = ringBuffer.get(sequence);
            // 空事件添加业务信息
            stringEvent.setValue(content);
        } finally {
            // 发布
            ringBuffer.publish(sequence);
        }
    }
}

• 事件处理类，收到事件后具体的业务处理逻辑：

package com.bolingcavalry.service;

import com.lmax.disruptor.EventHandler;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import java.util.function.Consumer;

@Slf4j
public class StringEventHandler implements EventHandler {

    public StringEventHandler(Consumer<?> consumer) {
        this.consumer = consumer;
    }

    // 外部可以传入Consumer实现类，每处理一条消息的时候，consumer的accept方法就会被执行一次
    private Consumer<?> consumer;

    @Override
    public void onEvent(StringEvent event, long sequence, boolean endOfBatch) throws Exception {
        log.info("sequence [{}], endOfBatch [{}], event : {}", sequence, endOfBatch, event);

        // 这里延时100ms，模拟消费事件的逻辑的耗时
        Thread.sleep(100);

        // 如果外部传入了consumer，就要执行一次accept方法
        if (null!=consumer) {
            consumer.accept(null);
        }
    }
}

• 定义一个接口，外部通过调用接口的方法来生产消息，再放几个常量在里面后面会用到：

package com.bolingcavalry.service;

public interface LowLevelOperateService {
    /**
     * 消费者数量
     */
    int CONSUMER_NUM = 3;

    /**
     * 环形缓冲区大小
     */
    int BUFFER_SIZE = 16;

    /**
     * 发布一个事件
     * @param value
     * @return
     */
    void publish(String value);

    /**
     * 返回已经处理的任务总数
     * @return
     */
    long eventCount();
}

• 以上就是公共代码了，接下来逐个实现之前规划的三个场景；

100个事件，单个消费者消费

• 这是最简单的功能了，实现发布消息和单个消费者消费的功能，代码如下，有几处要注意的地方稍后提到：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.*;
import com.lmax.disruptor.BatchEventProcessor;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.SequenceBarrier;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;

@Service("oneConsumer")
@Slf4j
public class OneConsumerServiceImpl implements LowLevelOperateService {

    private RingBuffer ringBuffer;

    private StringEventProducer producer;

    /**
     * 统计消息总数
     */
    private final AtomicLong eventCount = new AtomicLong();

    private ExecutorService executors;

    @PostConstruct
    private void init() {
        // 准备一个匿名类，传给disruptor的事件处理类，
        // 这样每次处理事件时，都会将已经处理事件的总数打印出来
        Consumer<?> eventCountPrinter = new Consumer

阿哇教育

www.awaedu.com

作文哥

www.zuowenge.cn

搜码吧

www.somanba.cn

教程弟

www.jcdi.cn