Disruptor原理概述与轻量级C++实现

       最近学习了disruptor，于是自己实现了一个极轻量化的多生产者多消费者c++版本disruptor，并用这个版本优化了github上排第一的threadpool项目，效率得到了一定的提升，特别是执行函数相对比mutex锁所需时间较小时候。

       源码地址：https://github.com/WoBuShiXiaoKang/DisruptorThreadPool/tree/master

       老哥们顺手去给个star呗~

目录

1、disruptor概述

2、C++实现

（1）序号类Sequence和AtomicSequence：

（2）Disruptor类

（3）BufConsumer类

3、应用于线程池

4、不足

---

---

1、disruptor概述

       关于disruptor的详细介绍可以拜读Disruptor的论文，中文翻译见https://www.cnblogs.com/daoqidelv/p/7043696.html，下面给出总结，欢迎补充指正：

1. Disruptor的核心目的是消除锁（mutex的开销很大）。做法是隔离生产者与消费者之间，各生产者之间，各消费者之间对缓存队列的操作（原始的单队列缓存，每个生产者或消费者对队列操作都需要加锁，因为push和pop都是对队列的写操作），具体做法是预先分配缓存队列的大小，各生产者与消费者只是获取其中的槽位下标，然后对自己的槽位进行写或者读操作，这样就不需要对整个队列读写操作过程进行加锁。
2. 减轻GC机制负担。队列每一个元素pop实际都delete了那个节点，对GC机制造成负担。

 

2、C++实现

（1）序号类Sequence和AtomicSequence：

       该类封装了int64_t和std::atomic_int64_t，进行内存补齐保证_seq在一个缓存行中，以防止false sharing（http://ifeve.com/falsesharing/）：

#define CACHELINE_SIZE_BYTES 64
#define CACHELINE_PADDING_FOR_ATOMIC_INT64_SIZE (CACHELINE_SIZE_BYTES - sizeof(std::atomic_int64_t))
#define CACHELINE_PADDING_FOR_INT64_SIZE (CACHELINE_SIZE_BYTES - sizeof(int64_t))

namespace Kang {

	//对std::atomic_int64_t进行了封装，内存补齐保证_seq在一个缓存行中
	class AtomicSequence
	{
	public:
		AtomicSequence(int64_t num = 0L) : _seq(num) {};
		~AtomicSequence() {};
		AtomicSequence(const AtomicSequence&) = delete;
		AtomicSequence(const AtomicSequence&&) = delete;
		void operator=(const AtomicSequence&) = delete;

		void store(const int64_t val)//, std::memory_order _order = std::memory_order_seq_cst)
		{
			_seq.store(val);//,_order);
		}

		int64_t load()//std::memory_order _order = std::memory_order_seq_cst)
		{
			return _seq.load();// _order);
		}

		int64_t fetch_add(const int64_t increment)//, std::memory_order _order = std::memory_order_seq_cst)
		{
			return _seq.fetch_add(increment);// _order);
		}

	private:
		//两边都补齐，以保证_seq不会与其它变量共享一个缓存行
		char _frontPadding[CACHELINE_PADDING_FOR_ATOMIC_INT64_SIZE];
		std::atomic_int64_t _seq;
		char _backPadding[CACHELINE_PADDING_FOR_ATOMIC_INT64_SIZE];
	};

	//对int64_t进行了封装，内存补齐保证_seq在一个缓存行中
	class Sequence
	{
	public:
		Sequence(int64_t num = 0L) : _seq(num) {};
		~Sequence() {};
		Sequence(const Sequence&) = delete;
		Sequence(const Sequence&&) = delete;
		void operator=(const Sequence&) = delete;

		void store(const int64_t val)
		{
			_seq = val;
		}

		int64_t load()
		{
			return _seq;
		}

	private:
		//两边都补齐