c++千万数据级别正确使用无锁队列，避免内存撕碎(一)

1、 内存 2、时间计算类

这个时间计算在我以前的文章里面都有

class TicToc
{
public:
	TicToc()
	{
		tic();
	}

	void tic()
	{
		start = std::chrono::system_clock::now();
	}

	double toc()
	{
		end = std::chrono::system_clock::now();
		std::chrono::duration elapsed_seconds = end - start;
		start = end;
		return elapsed_seconds.count() * 1000;
	}

private:
	std::chrono::time_point start, end;
};

还是依照以前的习惯，写好时间计算类

3、定义数据结构

struct s_data
{
	uint8_t* data = NULL;
	size_t len = 0;
	s_data(const char* in)
	{
		len = strlen(in);
		data = (uint8_t*)malloc(len+1);
		if (data == NULL)
			return;
		memcpy(data, in, len);
		data[len] = '\0';
	}
	~s_data()
	{
		if (data != NULL)
			free(data);
	}
};
typedef std::shared_ptr ptr_s_data;

我们之所以使用智能指针，是希望程序直接释放，在不需要的时候直接内存放弃

4、boost 无锁队列

boost 无锁数据结构：以下摘自于boost文档 boost.lockfree implements three lock-free data structures:

boost::lockfree::queue a lock-free multi-produced/multi-consumer queue

boost::lockfree::stack a lock-free multi-produced/multi-consumer stack

boost::lockfree::spsc_queue a wait-free single-producer/single-consumer queue (commonly known as ringbuffer)

下面我们使用spsc_queue

boost::lockfree::spsc_queue spsc_queue;

1、这是个单生产者，单消费者，多生产者，多消费者用处比较少，这里不使用，且以性能来说，spsc_queue的性能要高。高性能的程序不在于线程使用很多，而在于使用线程和内存以及cpu，gpu的合理性。 2、里面的100是指的程序缓冲，但值得注意的是：这个缓冲我们使用的是指针，而不是真实的数据空间。

使用指针空间意味着内存在外分配，我们成为带外分配，也就意味着内存容易撕裂。那我们应该怎么正确分配内存？一般来说，程序都会使用自己的内存管理，分配一个较大的内存，从中取得内存使用权限，有一个再分配管理。

int main()
{
	if (spsc_queue.is_lock_free())
		std::cout