disruptor笔记之一：快速入门

开摆

于 2024-05-04 01:42:55 发布

阅读量940

点赞数 16

分类专栏：程序员文章标签：笔记

本文链接：https://blog.csdn.net/2303_77877769/article/details/138430064

版权

程序员专栏收录该内容

746 篇文章 0 订阅

订阅专栏

springboot：2.3.8.RELEASE
disruptor：3.4.4

源码下载

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

| 名称 | 链接 | 备注 |

| :-- | :-- | :-- |

| 项目主页 | https://github.com/zq2599/blog_demos | 该项目在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的gradle工程，build.gradle如下：

import java.time.OffsetDateTime

import java.time.format.DateTimeFormatter

buildscript {

repositories {

maven {

url ‘https://plugins.gradle.org/m2/’

}

// 如果有私服就在此配置，如果没有请注释掉

maven {

url ‘http://192.168.50.43:8081/repository/aliyun-proxy/’

}

// 阿里云

maven {

url ‘http://maven.aliyun.com/nexus/content/groups/public/’

}

mavenCentral()

}

ext {

// 项目版本

projectVersion = ‘1.0-SNAPSHOT’

// sprignboot版本 https://github.com/spring-projects/spring-boot/releases

springBootVersion = ‘2.3.8.RELEASE’

}

plugins {

id ‘java’

id ‘java-library’

id ‘org.springframework.boot’ version “${springBootVersion}” apply false

id ‘io.spring.dependency-management’ version ‘1.0.11.RELEASE’

id ‘net.nemerosa.versioning’ version ‘2.14.0’

id ‘io.franzbecker.gradle-lombok’ version ‘4.0.0’ apply false

id ‘com.github.ben-manes.versions’ version ‘0.36.0’ // gradle dependencyUpdates

}

// If you attempt to build without the --scan parameter in gradle 6.0+ it will cause a build error that it can’t find

// a buildScan property to change. This avoids that problem.

if (hasProperty(‘buildScan’)) {

buildScan {

termsOfServiceUrl = ‘https://gradle.com/terms-of-service’

termsOfServiceAgree = ‘yes’

}

wrapper {

gradleVersion = ‘6.7.1’

}

def buildTimeAndDate = OffsetDateTime.now()

ext {

// 构建时取得当前日期和时间

buildDate = DateTimeFormatter.ISO_LOCAL_DATE.format(buildTimeAndDate)

buildTime = DateTimeFormatter.ofPattern(‘HH:mm:ss.SSSZ’).format(buildTimeAndDate)

buildRevision = versioning.info.commit

}

allprojects {

apply plugin: ‘java’

apply plugin: ‘idea’

apply plugin: ‘eclipse’

apply plugin: ‘io.spring.dependency-management’

apply plugin: ‘io.franzbecker.gradle-lombok’

compileJava {

sourceCompatibility = JavaVersion.VERSION_1_8

targetCompatibility = JavaVersion.VERSION_1_8

options.encoding = ‘UTF-8’

}

compileJava.options*.compilerArgs = [

‘-Xlint:all’, ‘-Xlint:-processing’

]

// Copy LICENSE

tasks.withType(Jar) {

from(project.rootDir) {

include ‘LICENSE’

into ‘META-INF’

}

// 写入到MANIFEST.MF中的内容

jar {

manifest {

attributes(

‘Created-By’: “ ${System.properties['java.version']} ($ {System.properties[‘java.vendor’]} ${System.properties[‘java.vm.version’]})”.toString(),

‘Built-By’: ‘travis’,

‘Build-Date’: buildDate,

‘Build-Time’: buildTime,

‘Built-OS’: “${System.properties[‘os.name’]}”,

‘Build-Revision’: buildRevision,

‘Specification-Title’: project.name,

‘Specification-Version’: projectVersion,

‘Specification-Vendor’: ‘Will Zhao’,

‘Implementation-Title’: project.name,

‘Implementation-Version’: projectVersion,

‘Implementation-Vendor’: ‘Will Zhao’

)

}

repositories {

mavenCentral()

// 如果有私服就在此配置，如果没有请注释掉

maven {

url ‘http://192.168.50.43:8081/repository/aliyun-proxy/’

}

// 阿里云

maven {

url ‘http://maven.aliyun.com/nexus/content/groups/public/’

}

jcenter()

}

buildscript {

repositories {

maven { url ‘https://plugins.gradle.org/m2/’ }

}

allprojects { project ->

buildscript {

dependencyManagement {

imports {

mavenBom “org.springframework.boot:spring-boot-starter-parent:${springBootVersion}”

mavenBom “org.junit:junit-bom:5.7.0”

}

dependencies {

dependency ‘org.projectlombok:lombok:1.16.16’

dependency ‘org.apache.commons:commons-lang3:3.11’

dependency ‘commons-collections:commons-collections:3.2.2’

dependency ‘com.lmax:disruptor:3.4.4’

}

ext {

springFrameworkVersion = dependencyManagement.importedProperties[‘spring-framework.version’]

}

group = ‘bolingcavalry’

version = projectVersion

接下来编写消息发布和消费的代码；

新建module

前面新建了整个《Disruptor笔记》系列的父工程，现在新建名为basic-event的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’)

}

这个module是个springboot应用，启动类如下：

package com.bolingcavalry;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class BasicEventApplication {

public static void main(String[] args) {

SpringApplication.run(BasicEventApplication.class, args);

}

接下来按照前面总结的套路行事；

事件的定义

事件定义类StringEvent.java，可见就是个普普通通的java bean：

package com.bolingcavalry.service;

import lombok.Data;

import lombok.NoArgsConstructor;

import lombok.ToString;

@Data

@ToString

@NoArgsConstructor

public class StringEvent {

private String value;

}

事件工厂

事件工厂的作用，是让disruptor知道如何在内存中创建一个事件实例，不过，该实例和业务还没有任何关系，本篇的事件工厂如下，可见就是创建StringEvent实例，并没有特别的操作：

package com.bolingcavalry.service;

import com.lmax.disruptor.EventFactory;

public class StringEventFactory implements EventFactory {

@Override

public StringEvent newInstance() {

return new StringEvent();

}

事件处理

时间处理类的作用是定义一个事件如何被消费，里面是具体的业务代码，每个事件都会执行此类的onEvent方法；
本篇的事件处理类做的事情是打印事件内容，再用sleep消耗100毫秒，然后再调用外部传入的Consumer实现类的accept方法：

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);

}

事件生产者

每当业务要生产一个事件时，就会调用事件生产者的onData方法，将业务数据作为入参传进来，此时生产者会从环形队列中取出一个事件实例（就是前面的事件工厂创建的），把业务数据传给这个实例，再把实例正式发布出去：

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);

}

初始化逻辑

开发一个spring bean，这里面有disruptor的初始化逻辑，有几处需要关注的地方稍后会说到：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.*;

import com.lmax.disruptor.RingBuffer;

import com.lmax.disruptor.dsl.Disruptor;

import com.lmax.disruptor.util.DaemonThreadFactory;

import lombok.extern.slf4j.Slf4j;

import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

import java.time.LocalDateTime;

import java.util.concurrent.Executor;

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

import java.util.function.Consumer;

@Service

@Slf4j

public class BasicEventServiceImpl implements BasicEventService {

private static final int BUFFER_SIZE = 16;

private Disruptor disruptor;

private StringEventProducer producer;

/**

统计消息总数

private final AtomicLong eventCount = new AtomicLong();

@PostConstruct

private void init() {

Executor executor = Executors.newCachedThreadPool();

// 实例化

disruptor = new Disruptor<>(new StringEventFactory(),

BUFFER_SIZE,

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
t() {

Executor executor = Executors.newCachedThreadPool();

// 实例化

disruptor = new Disruptor<>(new StringEventFactory(),

BUFFER_SIZE,

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

[外链图片转存中…(img-HSqL2LnO-1714758163987)]

[外链图片转存中…(img-HxU8YZgx-1714758163988)]

[外链图片转存中…(img-JcwkadCO-1714758163988)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

开摆

关注

16
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
disruptor笔记之一：快速入门

事件定义类StringEvent.java，可见就是个普普通通的java bean：@Data@ToString自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
复制链接

扫一扫