高性能队列--Disruptor

背景

Disruptor是英国外汇交易公司LMAX开发的一个高性能队列。基于Disruptor开发的系统单线程可以支撑每秒600万的订单。

那么,这种高性能的内存队列是如何实现的呢?

JAVA内置的队列

目前java内置的队列有以下几种
高性能队列--Disruptor_第1张图片
为了在并发场景下保证线程的安全,上面的内置队列都使用了CAS或者锁的技术,那么使用CAS或者锁会对性能造成多大的影响呢?

Disruptor论文中讲述了一个实验:

这个测试程序调用了一个函数,该函数会对一个64位的计数器循环自增5亿次。
机器环境:2.4G 6核
运算: 64位的计数器累加5亿次

|Method | Time (ms) | |— | —| |Single thread | 300| |
Single thread with CAS | 5,700| |
Single thread with lock | 10,000| |
Single thread with volatile write | 4,700| |
Two threads with CAS | 30,000| |
Two threads with lock | 224,000|

结论:
加锁:比单线程无锁慢3个数量级
CAS:比单线程无锁慢1个数量级

单线程情况下,不加锁的性能 > CAS操作的性能 > 加锁的性能

理论上在高度竞争环境中,锁的性能会大于CAS的性能,但是在真实业务中,并没有那么多激烈的高度竞争场景(几十上百个线程争夺一个锁),所以尽量选择不加锁或者使用CAS来提高系统性能

CPU与缓存

下面是CPU与缓存的示意图,查询效率比较:L1>L2>L3>主存
高性能队列--Disruptor_第2张图片

下面是CPU访问通过不同层级缓存数据的时间概念
高性能队列--Disruptor_第3张图片
越靠近CPU的缓存,查询效率越高。效率是高了,但是如果缓存持有的数据是过期无效数据,那查询效率再高也没用。

缓存行概念

cache是由多个cache line组成的,每个cache line 通常是64个字节,并且它有效地引用内存中的一块地址。cpu每次从主存中拉取数据时,都会将相邻的数据一块放入cache line。

下面是一个测试用例,证明使用cache line的特性和不使用cache line特性的对比

public class CacheLineEffect {
    //考虑一般缓存行大小是64字节,一个 long 类型占8字节
    static  long[][] arr;
 
    public static void main(String[] args) {
        // 构造二维数组,并填充数据
        arr = new long[1024 * 1024][];
        for (int i = 0; i < 1024 * 1024; i++) {
            // 这8个long数据在读取的时候会被一次性加载到缓存行中
            arr[i] = new long[8];
            for (int j = 0; j < 8; j++) {
                arr[i][j] = 0L;
            }
        }
        long sum = 0L;
        long marked = System.currentTimeMillis();
        for (int i = 0; i < 1024 * 1024; i+=1) {
            // 拿到第一个arr[i][0]的时候已经把后面arr[i][1]-arr[i][7]的7个long数据一起加载进缓存行了,这样接下来就不用再加载了
            for(int j =0; j< 8;j++){
                sum = arr[i][j];
            }
        }
        System.out.println("Loop times:" + (System.currentTimeMillis() - marked) + "ms");
 
        marked = System.currentTimeMillis();
        for (int i = 0; i < 8; i+=1) {
            // 拿到第一个arr[j][0],就已经把后面的arr[j][1]-arr[j][7]的数据全部拿出来了,但是接下来cpu不使用这些数据,使用的是arr[j+1][0]数据,还得重新拿,浪费时间
            for(int j =0; j< 1024 * 1024;j++){
                sum = arr[j][i];
            }
        }
        System.out.println("Loop times:" + (System.currentTimeMillis() - marked) + "ms");
    }
}

伪共享概念

上面代码示例中没有使用到cache line的情形就是伪共享的概念。这种无法充分使用缓存行特性的现象,就叫伪共享。

比如:两个cpu都加载同一个对象到自己的缓存行中,当一个cpu修改对象中的属性,另一个cpu加载到缓存行中的对象数据就失效,还得重新加载一遍对象数据,从而达不到内存共享的效果。

高性能队列--Disruptor_第4张图片
解决思路:增大数组元素间隔,使不同的线程加载到缓存行中的数据互不干扰,以空间换时间。避免线程操作当前缓存行中的数据,造成其它线程中的缓存行的数据失效。

public class FalseSharing implements Runnable{
        public final static long ITERATIONS = 500L * 1000L * 100L;
        private int arrayIndex = 0;
 
        private static ValuePadding[] paddingObjArr;
        public FalseSharing(final int arrayIndex) {
            this.arrayIndex = arrayIndex;
        }
 
        public static void main(final String[] args) throws Exception {
            for(int i=1;i<10;i++){
                System.gc();
                final long start = System.currentTimeMillis();
                // 不同数量的线程并发执行,测试效果如何
                runTest(i);
                System.out.println("Thread num "+i+" duration = " + (System.currentTimeMillis() - start));
            }
 
        }
 
        private static void runTest(int NUM_THREADS) throws InterruptedException {
            // 创建存储N个paddingObj的数组
            paddingObjArr = new ValuePadding[NUM_THREADS];
            for (int i = 0; i < NUM_THREADS; i++) {
                paddingObjArr[i] = new ValuePadding();
            }
            // 创建N个线程
            Thread[] threads = new Thread[NUM_THREADS];
            for (int i = 0; i < NUM_THREADS; i++) {
                // 每个线程拿到各自的下标
                threads[i] = new Thread(new FalseSharing(i));
            }
 
            for (Thread t : threads) {
                t.start();
            }
 
            for (Thread t : threads) {
                t.join();
            }
        }
 
        public void run() {
            long i = ITERATIONS + 1;
            while (0 != --i) {
                // 各自的线程处理各自数组下标下的对象的属性值
                // 如果使用ValuePadding,因为线程之间加载的对象不在一个cache line中,导致线程修改自己对象的值,不会使其它线程的cache line失效,相互之间不会有影响
                paddingObjArr[arrayIndex].value = 0L;
            }
        }
 
        public final static class ValuePadding {
            // 前面填充7个long,后面填充7个long,保证两个对象肯定加载不到同一个cache line中
            protected long p1, p2, p3, p4, p5, p6, p7;
            protected volatile long value = 0L;
            protected long p9, p10, p11, p12, p13, p14;
            protected long p15;
        }
        public final static class ValueNoPadding {
            // protected long p1, p2, p3, p4, p5, p6, p7;
            protected volatile long value = 0L;
            // protected long p9, p10, p11, p12, p13, p14, p15;
        }
}

使用ValuePadding测试结果如下:
高性能队列--Disruptor_第5张图片

使用ValueNoPadding测试结果如下:
高性能队列--Disruptor_第6张图片
总之一句话就是,你别的线程修改数据可以,但是不要影响到我这个线程使用的cache line的有效性,让我这个线程的cache line失效,我还得重新去主内存查找,这性能就慢了。

Disruptor核心RingBuffer

下面是单线程生产者,单线程消费者的代码demo

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.ProducerType;
import java.util.concurrent.Executors;

public class DisruptorMain {
    public static class MyEvent{
        private int value;
        public int get() {
            return value;
        }
        public void set(int value) {
            this.value = value;
        }
    }
    public static void main(String[] args) throws Exception {
        // 创建一个RingBuffer环形队列
        RingBuffer<MyEvent> ringBuffer = RingBuffer.create(ProducerType.SINGLE, new EventFactory<MyEvent>() {
            @Override
            public MyEvent newInstance() {
                return new MyEvent();
            }
        },16,new BlockingWaitStrategy());

        // 单线程消费者逻辑
        SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();
        // 创建processor
        BatchEventProcessor batchEventProcessor = new BatchEventProcessor<MyEvent>(ringBuffer, sequenceBarrier, new EventHandler<MyEvent>() {
            @Override
            public void onEvent(MyEvent myEvent, long l, boolean b) throws Exception {
                System.out.println(myEvent.get());
            }
        });
        // 给ringBuffer添加上batchEventProcessor的序列号,用于判断最后消费的是哪个序列号,以便生产者插入新消息时知道下一个位置可不可以写入覆盖
        ringBuffer.addGatingSequences(batchEventProcessor.getSequence());
        Executors.newFixedThreadPool(1).submit(batchEventProcessor);
        // 单线程消费者逻辑完成

        // 单线程生产者逻辑
        for (int num = 0; ; num++) {
            long sequence = ringBuffer.next();
            try {
                ringBuffer.get(sequence).set(num);
            } finally {
                ringBuffer.publish(sequence);
            }
            Thread.sleep(200);
        }
        // 单线程生产者逻辑结束
    }
}

下面是单线程生产者(多线程与单线程生产者的代码都是自己实现的,随意写),多线程消费者的代码逻辑

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.ProducerType;
import java.util.concurrent.Executors;

public class DisruptorMain {
    public static class MyEvent{
        private int value;
        public int get() {
            return value;
        }
        public void set(int value) {
            this.value = value;
        }
    }
    public static void main(String[] args) throws Exception {
        // 创建一个RingBuffer环形队列
        RingBuffer<MyEvent> ringBuffer = RingBuffer.create(ProducerType.SINGLE, new EventFactory<MyEvent>() {
            @Override
            public MyEvent newInstance() {
                return new MyEvent();
            }
        },16,new BlockingWaitStrategy());

        // 单线程消费者逻辑
        SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();
        // 创建一组消费者
        WorkHandler[] workHandlers = new WorkHandler[10];
        for(int i=0;i<workHandlers.length;i++){
            workHandlers[i] = new WorkHandler<MyEvent>() {
                @Override
                public void onEvent(MyEvent myEvent) throws Exception {
                    System.out.println("Thread:"+Thread.currentThread().getId()+",Value: "+myEvent.get());
                }
            };
        }
        // 创建消费者工作池
        WorkerPool<MyEvent> workerPool = new WorkerPool<MyEvent>(
                ringBuffer,
                sequenceBarrier,
                new ExceptionHandler<MyEvent>() {
                    @Override
                    public void handleEventException(Throwable throwable, long l, MyEvent myEvent) {
                    }
                    @Override
                    public void handleOnStartException(Throwable throwable) {
                    }
                    @Override
                    public void handleOnShutdownException(Throwable throwable) {
                    }
                },
                workHandlers);
        // 给ringBuffer添加上batchEventProcessor的序列号,用于判断最后消费的是哪个序列号,以便生产者插入新消息时知道下一个位置可不可以写入覆盖
        ringBuffer.addGatingSequences(workerPool.getWorkerSequences());
        // 使用线程池启动workPool
        workerPool.start(Executors.newFixedThreadPool(workHandlers.length));
        // 多线程消费逻辑完成


        // 单线程生产者逻辑
        for (int num = 0; ; num++) {
            long sequence = ringBuffer.next();
            try {
                ringBuffer.get(sequence).set(num);
            } finally {
                ringBuffer.publish(sequence);
            }
            Thread.sleep(200);
        }
        // 单线程生产者逻辑结束
    }
}

我们在工厂中经常看到工人在流水线上高效的作业,每个工人(CPU)都不会闲着,产品生产速度达到最大化。

同样的原理可以适用于软件,在RingBuffer这条流水线上,我们同样可以安排N多个工人进行高效作业,保证产品生产速度最大化。一套完善的任务分解方案(力度够细,且相互不影响)非常重要,可以保证各个CPU的高效协同作业,保证运行速度的最大化

当前的RingBuffer是单机性能优化到极致,同样的原理也可以应用于集群分布式场景,例如流处理等

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.ProducerType;
import java.util.concurrent.Executors;

public class DisruptorMain {
    public static class MyEvent{
        private String value;
        public String get() {
            return value;
        }
        public void set(String value) {
            this.value = value;
        }
    }
    public static void main(String[] args) throws Exception {
        // 创建一个RingBuffer环形队列
        RingBuffer<MyEvent> ringBuffer = RingBuffer.create(ProducerType.SINGLE, new EventFactory<MyEvent>() {
            @Override
            public MyEvent newInstance() {
                return new MyEvent();
            }
        },16,new BlockingWaitStrategy());

        // stage 1
        BatchEventProcessor batchEventProcessor = new BatchEventProcessor<MyEvent>(ringBuffer,
                ringBuffer.newBarrier(),
                new EventHandler<MyEvent>() {
                    @Override
                    public void onEvent(MyEvent myEvent, long l, boolean b) throws Exception {
                        myEvent.set("age:"+myEvent.get());
                        System.out.println("我需要将这个值追加一个前缀:age,"+myEvent.get());
                    }
                });
        // 给ringBuffer添加上batchEventProcessor的序列号,用于判断最后消费的是哪个序列号,以便生产者插入新消息时知道下一个位置可不可以写入覆盖
        ringBuffer.addGatingSequences(batchEventProcessor.getSequence());



        // stage 2
        // 创建一组消费者
        WorkHandler[] workHandlers = new WorkHandler[10];
        for(int i=0;i<workHandlers.length;i++){
            workHandlers[i] = new WorkHandler<MyEvent>() {
                @Override
                public void onEvent(MyEvent myEvent) throws Exception {
                    System.out.println("Thread:"+Thread.currentThread().getId()+",我只是将这个字符串打印出来,StringValue: "+myEvent.get());
                }
            };
        }
        // 创建消费者工作池
        WorkerPool<MyEvent> workerPool = new WorkerPool<MyEvent>(
                ringBuffer,
                ringBuffer.newBarrier(batchEventProcessor.getSequence()),
                new ExceptionHandler<MyEvent>() {
                    @Override
                    public void handleEventException(Throwable throwable, long l, MyEvent myEvent) {
                    }
                    @Override
                    public void handleOnStartException(Throwable throwable) {
                    }
                    @Override
                    public void handleOnShutdownException(Throwable throwable) {
                    }
                },
                workHandlers);
        // 给ringBuffer添加上batchEventProcessor的序列号,用于判断最后消费的是哪个序列号,以便生产者插入新消息时知道下一个位置可不可以写入覆盖
        ringBuffer.addGatingSequences(workerPool.getWorkerSequences());

        // 启动processor
        Executors.newFixedThreadPool(1).submit(batchEventProcessor);
        // 使用线程池启动workPool
        workerPool.start(Executors.newFixedThreadPool(workHandlers.length));
        // 多线程消费逻辑完成


        // 单线程生产者逻辑
        for (int num = 0; ; num++) {
            long sequence = ringBuffer.next();
            try {
                ringBuffer.get(sequence).set(num+"");
            } finally {
                ringBuffer.publish(sequence);
            }
            Thread.sleep(200);
        }
        // 单线程生产者逻辑结束
    }
}

从以上的代码示例中,我们可以得到这么一个结论:我们可以在RingBuffer中对Event进行先行处理,使用屏障来保证各处理任务之间的执行顺序,以达到高并发的性能效果

等待策略

//BlockingWaitStrategy 是最低效的策略,但其对CPU的消耗最小并且在各种不同部署环境中能提供更加一致的性能表现
WaitStrategy BLOCKING_WAIT = new BlockingWaitStrategy();
//SleepingWaitStrategy 的性能表现跟BlockingWaitStrategy差不多,对CPU的消耗也类似,但其对生产者线程的影响最小,适合用于异步日志类似的场景
WaitStrategy SLEEPING_WAIT = new SleepingWaitStrategy();
//YieldingWaitStrategy 的性能是最好的,适合用于低延迟的系统。在要求极高性能且事件处理线数小于CPU逻辑核心数的场景中,推荐使用此策略;例如,CPU开启超线程的特性
WaitStrategy YIELDING_WAIT = new YieldingWaitStrategy();

Disruptor用例

RingBuffer是Disruptor的核心,下面是Disruptor的一个demo示例

/** 每1秒钟向Disruptor插入一个数据,消费者读取数据并打印(单线程) **/
import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
import java.util.concurrent.ThreadFactory;
public class DisruptorMain {

    public static class MyEvent{
        private int value;

        public int get() {
            return value;
        }

        public void set(int value) {
            this.value = value;
        }
    }

    public static void main(String[] args) throws Exception {
        // 生产者的线程工厂
        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r, "simpleThread");
            }
        };

        // RingBuffer生产工厂,初始化RingBuffer的时候使用
        EventFactory<MyEvent> eventFactory = new EventFactory<MyEvent>() {
            @Override
            public MyEvent newInstance() {
                return new MyEvent();
            }
        };

        // 处理Event的handler
        EventHandler<MyEvent> eventHandler = new EventHandler<MyEvent>() {
            @Override
            public void onEvent(MyEvent event, long sequence, boolean endOfBatch) {
                System.out.println("Element: " + event.get());
            }
        };

        // 创建disruptor,采用单生产者模式
        Disruptor<MyEvent> disruptor = new Disruptor(eventFactory, 256, threadFactory, ProducerType.SINGLE, new BlockingWaitStrategy());

        // 设置EventHandler
        disruptor.handleEventsWith(eventHandler);

        // 启动disruptor的线程
        disruptor.start();

        RingBuffer<MyEvent> ringBuffer = disruptor.getRingBuffer();
        // 单线程插入数据
        for (int num = 0; ; num++) {
            long sequence = ringBuffer.next();
            try {
                ringBuffer.get(sequence).set(num);
            } finally {
                ringBuffer.publish(sequence);
            }
            Thread.sleep(1000);
        }
    }
}

参考文档:
https://tech.meituan.com/2016/11/18/disruptor.html

你可能感兴趣的:(高并发,高并发,队列,java)