2024年Java最新系统性能典型案例分析:高性能队列Disruptor,一文深入理解,思维导图+源代码+笔记+项目

总结

这个月马上就又要过去了,还在找工作的小伙伴要做好准备了,小编整理了大厂java程序员面试涉及到的绝大部分面试题及答案,希望能帮助到大家

在这里插入图片描述

在这里插入图片描述

本文已被CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友,可以点击这里获取

  • 能够避免伪共享,提升缓存利用率。3. 采用无锁算法,避免频繁加锁、解锁的性能消耗。

  • 支持批量消费,消费者可以无锁方式消费多个消息。

今天我们先来聊一聊 Disruptor 怎么使用的,好让你们先对 Disruptor 有个提前的认识。

下面是官方出示的代码,我稍微修改了一下,相较而言,Disruptor 的使用比 Java SDK提供 BlockingQueue 要难懂一些,但是总体上来说是差不多的,其大致情况如下:

  • 生产者生产的对象称为 Event,使用Disruptor 必须自定义 Event,例如示例代码的自定义 Event 是 LongEvent,这是在 Disruptor 中的。

  • 需要传入一个 EventFactory才能构建 Disruptor 对象除了要指定队列大小,还示例代码中传入的是LongEvent::new;

  • 消费 Disruptor 中的 Event 需要通过 handleEventsWith() 方法注册一个事件处理器,发布 Event 则需要通过 publishEvent() 方法。

/* 自定义 Event */

class LongEvent {

private long value;

public void set( long value )

{

this.value = value;

}

}

/* 指定 RingBuffer 大小, 9 // 必须是 2 的 N 次方 */

int bufferSize = 1024;

/* 构建 Disruptor */

Disruptor disruptor

= new Disruptor<>(

LongEvent: : new,

bufferSize,

DaemonThreadFactory.INSTANCE );

/* 注册事件处理器 */

disruptor.handleEventsWith(

(event, sequence, endOfBatch) - >

System.out.println( "E: " + event ) );

/* 启动 Disruptor */

disruptor.start();

/* 获取 RingBuffer */

RingBuffer ringBuffer

= disruptor.getRingBuffer();

/* 生产 Event */

ByteBuffer bb = ByteBuffer.allocate( 8 );

for ( long l = 0; true; l++ )

{

bb.putLong( 0, l );

/* 生产者生产消息 */

ringBuffer.publishEvent(

(event, sequence, buffer) - >

event.set( buffer.getLong( 0 ) ), bb );

Thread.sleep( 1000 );

}

RingBuffer 是怎样提升性能的?

=======================================================================================

Java SDK 中 ArrayBlockingQueue 使用数组作为底层的数据存储,而 Disruptor 是使用RingBuffer作为数据存储。RingBuffer 本质上也是数组,所以仅仅将数据存储从数组换成RingBuffer 并不能提升性能,但是 Disruptor 在 RingBuffer 的基础上还做了很多优化,其中一项优化就是和内存分配有关的。

在介绍这项优化之前,你需要先了解一下程序的局部性原理。简单来讲,程序的局部性原理指的是在一段时间内程序的执行会限定在一个局部范围内。这里的“局部性”可以从两个方面来理解,一个是时间局部性,另一个是空间局部性。

首先是 ArrayBlockingQueue。生产者线程向 ArrayBlockingQueue 增加一个元素,每次增加元素 E 之前,都需要创建一个对象 E,如下图所示,ArrayBlockingQueue 内部有 6个元素这 6 个元素都是由生产者线程创建的,由于创建这些元素的时间基本上是离散的,所以这些元素的内存地址大概率也不是连续的。

在这里插入图片描述

接下来我们来看 Disruptor 是怎么处理的。Disruptor 内部的 RingBuffer 也是用数组实现的,但是这个数组中的所有元素在初始化时是一次性全部创建的,所以这些元素的内存地址大概率是连续的,相关的代码如下所示。image.png

Disruptor 内部 RingBuffer 的结构可以简化成下图,那么数组中所有元素内存地址为什么能连续提升性能呢?因在消费者线程在消费时,遵循的是空间局部性原理的,消费完第 1 个元素,很快就会消费第 2 个元素;当消费第 1 个元素 E1 的时候,CPU 会把内存中 E1 后面的数据也加载进 Cache,如果 E1 和 E2 在内存中的地址是连续的,那么 E2 也就会被加载进 Cache 中,然后当消费第 2 个元素的时候,由于 E2 已经在Cache 中了,所以就不需要从内存中加载了,这样性能就能提升了

系统性能典型实战案例分析:高性能队列Disruptor,超详细

除此之外,在 Disruptor 中,生产者线程通过 publishEvent() 发布 Event 的时候,并不是创建一个新的 Event,而是通过 event.set() 方法修改 Event, 也就是说 RingBuffer 创建的 Event 是可以循环利用的,这样还能避免频繁创建、删除 Event 导致的频繁 GC 问题。

如何避免“伪共享”

============================================================================

什么是伪共享

ArrayBlockingQueue有三个成员变量: - takeIndex:需要被取走的元素下标 - putIndex:可被元素插入的位置的下标 - count:队列中元素的数量

这三个变量很容易放到一个缓存行中,但是之间修改没有太多的关联。所以每次修改,都会使之前缓存的数据失效,从而不能完全达到共享的效果。

系统性能典型实战案例分析:高性能队列Disruptor,超详细

如上图所示,当生产者线程put一个元素到ArrayBlockingQueue时,putIndex会修改,从而导致消费者线程的缓存中的缓存行无效,需要从主存中重新读取。

这种无法充分使用缓存行特性的现象,称为伪共享。

对于伪共享,一般的解决方案是,增大数组元素的间隔使得由不同线程存取的元素位于不同的缓存行上,以空间换时间。

系统性能典型实战案例分析:高性能队列Disruptor,超详细

当 CPU 从内存中加载 takeIndex 的时候,会同时将 putIndex 以及 count 都加载进Cache。下图是某个时刻 CPU 中 Cache 的状况,为了简化,缓存行中我们仅列出了takeIndex 和 putIndex。

image.png

假设线程 A 运行在 CPU-1 上,执行入队操作,入队操作会修改 putIndex,而修改putIndex 会导致其所在的所有核上的缓存行均失效;此时假设运行在 CPU-2 上的线程执行出队操作,出队操作需要读取 takeIndex,由于 takeIndex 所在的缓存行已经失效,所以 CPU-2 必须从内存中重新读取。入队操作本不会修改 takeIndex,但是由于 takeIndex和 putIndex 共享的是一个缓存行,就导致出队操作不能很好地利用 Cache,这其实就是伪共享。简单来讲,伪共享指的是由于共享缓存行导致缓存无效的场景

ArrayBlockingQueue 的入队和出队操作是用锁来保证互斥的,所以入队和出队不会同时发生。如果允许入队和出队同时发生,那就会导致线程 A 和线程 B 争用同一个缓存行,这样也会导致性能问题。所以为了更好地利用缓存,我们必须避免伪共享,那如何避免呢?

image.png

方案很简单,每个变量独占一个缓存行、不共享缓存行就可以了,具体技术是缓存行填充

/* 前:填充 56 字节 */

class LhsPadding {

long p1, p2, p3, p4, p5, p6, p7;

}

class Value extends LhsPadding {

volatile long value;

}

/* 后:填充 56 字节 */

class RhsPadding extends Value {

long p9, p10, p11, p12, p13, p14, p15;

}

class Sequence extends RhsPadding {

/* 省略实现 */

}

总结

三个工作日收到了offer,头条面试体验还是很棒的,这次的头条面试好像每面技术都问了我算法,然后就是中间件、MySQL、Redis、Kafka、网络等等。

  • 第一个是算法

关于算法,我觉得最好的是刷题,作死的刷的,多做多练习,加上自己的理解,还是比较容易拿下的。

而且,我貌似是将《算法刷题LeetCode中文版》、《算法的乐趣》大概都过了一遍,尤其是这本

《算法刷题LeetCode中文版》总共有15个章节:编程技巧、线性表、字符串、栈和队列、树、排序、查找、暴力枚举法、广度优先搜索、深度优先搜索、分治法、贪心法、动态规划、图、细节实现题

最新出炉,头条三面技术四面HR,看我如何一步一步攻克面试官?

《算法的乐趣》共有23个章节:

最新出炉,头条三面技术四面HR,看我如何一步一步攻克面试官?

最新出炉,头条三面技术四面HR,看我如何一步一步攻克面试官?

  • 第二个是Redis、MySQL、kafka(给大家看下我都有哪些复习笔记)

基本上都是面试真题解析、笔记和学习大纲图,感觉复习也就需要这些吧(个人意见)

最新出炉,头条三面技术四面HR,看我如何一步一步攻克面试官?

  • 第三个是网络(给大家看一本我之前得到的《JAVA核心知识整理》包括30个章节分类,这本283页的JAVA核心知识整理还是很不错的,一次性总结了30个分享的大知识点)

最新出炉,头条三面技术四面HR,看我如何一步一步攻克面试官?

本文已被CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友,可以点击这里获取

了30个分享的大知识点)**

[外链图片转存中…(img-DTbmfT3Z-1714989796590)]

本文已被CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友,可以点击这里获取

  • 21
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是一个简单的 Java Disruptor 代码示例: ```java import com.lmax.disruptor.RingBuffer; import com.lmax.disruptor.dsl.Disruptor; import java.nio.ByteBuffer; import java.util.concurrent.Executor; import java.util.concurrent.Executors; public class LongEvent { private long value; public void set(long value) { this.value = value; } } class LongEventFactory implements EventFactory<LongEvent> { public LongEvent newInstance() { return new LongEvent(); } } class LongEventHandler implements EventHandler<LongEvent> { public void onEvent(LongEvent event, long sequence, boolean endOfBatch) { System.out.println("Event: " + event); } } public class DisruptorExample { public static void main(String[] args) { Executor executor = Executors.newCachedThreadPool(); LongEventFactory factory = new LongEventFactory(); int bufferSize = 1024; Disruptor<LongEvent> disruptor = new Disruptor<>(factory, bufferSize, executor); disruptor.handleEventsWith(new LongEventHandler()); RingBuffer<LongEvent> ringBuffer = disruptor.start(); ByteBuffer bb = ByteBuffer.allocate(8); for (long l = 0; true; l++) { bb.putLong(0, l); ringBuffer.publishEvent(new EventTranslatorOneArg<LongEvent, ByteBuffer>() { public void translateTo(LongEvent event, long sequence, ByteBuffer arg0) { event.set(arg0.getLong(0)); } }, bb); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } ``` 该代码使用 LMAX Disruptor 实现了一个简单的事件处理程序。Disruptor 可以高效地处理并发事件处理任务,例如高性能日志记录、消息传递和网络通信。在这个例子中,我们定义了一个事件对象 LongEvent,包含一个 long 值。我们使用 LongEventFactory 为 Disruptor 创建新的事件对象,使用 LongEventHandler 处理事件。我们还定义了一个 ByteBuffer,用于在主线程中创建事件并将其发布到 Disruptor 中。在主线程中,我们每秒钟创建一个新事件并将其发布到 Disruptor 中。在事件处理程序中,我们简单地打印事件。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值