disruptor笔记之一：快速入门(1)

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{[}^{\prime }java.versio{n}^{\prime }](${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,

new CustomizableThreadFactory(“event-handler-”));

// 准备一个匿名类，传给disruptor的事件处理类，

// 这样每次处理事件时，都会将已经处理事件的总数打印出来

Consumer<?> eventCountPrinter = new Consumer() {

@Override

public void accept(Object o) {

long count = eventCount.incrementAndGet();

log.info(“receive [{}] event”, count);

}

};

// 指定处理类

disruptor.handleEventsWith(new StringEventHandler(eventCountPrinter));

// 启动

disruptor.start();

// 生产者

producer = new StringEventProducer(disruptor.getRingBuffer());

}

@Override

public void publish(String value) {

producer.onData(value);

}

@Override

public long eventCount() {

return eventCount.get();

}

}

• 上述代码有以下几点需要注意：

1. publish方法给外部调用，用于发布一个事件；

2. eventCountPrinter是Consumer的实现类，被传给了StringEventHandler，这样StringEventHandler消费消息的时候，eventCount就会增加，也就记下了已经处理的事件总数；

3. Disruptor的构造方法中，BUFFER_SIZE表示环形队列的大小，这里故意设置为16，这样可以轻易的将环形队列填满，此时再发布事件会不会导致环形队列上的数据被覆盖呢？稍后咱们可以测一下；

4. 记得调用start方法；

web接口

再写一个web接口类，这样就可以通过浏览器验证前面的代码了：

package com.bolingcavalry.controller;

import com.bolingcavalry.service.BasicEventService;

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

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

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

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Java）

最后

一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。

这不，马上就要到招聘季了，很多朋友又开始准备“金三银四”的春招啦，那我想这份“java高分面试指南”应该起到不小的作用，所以今天想给大家分享一下。

请注意：关于这份“java高分面试指南”，每一个方向专题（25个）的题目这里几乎都会列举，在不看答案的情况下，大家可以自行测试一下水平 且由于篇幅原因，这边无法展示所有完整的答案解析
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
以上Java开发知识点，真正体系化！**

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Java）

[外链图片转存中…(img-wKozfISj-1713822724110)]

最后

一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。

这不，马上就要到招聘季了，很多朋友又开始准备“金三银四”的春招啦，那我想这份“java高分面试指南”应该起到不小的作用，所以今天想给大家分享一下。

[外链图片转存中…(img-0GQ6P5gn-1713822724110)]

请注意：关于这份“java高分面试指南”，每一个方向专题（25个）的题目这里几乎都会列举，在不看答案的情况下，大家可以自行测试一下水平 且由于篇幅原因，这边无法展示所有完整的答案解析
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！