实用的无锁队列（一）

写一个无锁队列的好处

针对应用场景写无锁队列好处是能够得到额外的cpu释放 1、 atomic_thread_fence C++11的原子库标准定义了一个可移植的函数atomic_thread_fence()，函数采用一个参数来指定fence的类型，内存屏障 2、atomic_compare_exchange_strong

定义数据结构

1、状态 typedef enum enum_status { en_read = 1, //can only read now en_write = 2,//can only write now en_middle = 3 //can both read and write }enum_status;

2、内存 对于RTP 接收这种内存块来说，是比较合适定义这样的循环队列的，根据MTU的大小来定义块大小，MTU不宜过大，因为很多传输系统传输RTP的时候需要额外的字节数，请留白，如1400字节，实际上字节可以达到1460字节，比如webrtc

typedef struct s_memory
{
#define M_MTU 1400
	size_t v_pack_num = 0;
	int flag = 0;
	uint8_t *v_mem = NULL;
	std::atomic_char v_lock = en_write; // write lock
	int v_size_total = 0;
	int v_size_use = 0;
	s_memory(int page_size)
	{
		if (page_size  0)
		{
			v_para = new s_memory(v_size_total);
		}
	}
	//user data point
	void * v_data = NULL;
}s_memory_block;

show me the code

class 封装

class c_data
{
private:
	s_memory v_root = NULL;
	s_memory *v_r = NULL;
	s_memory *v_w = NULL;
	int v_fin_flag = 0;

	//send the data and the result is what
	int v_send_result = 0;
	//we must save the state and some data
	//s_data_nfin v_storage_last;
public:
	~c_data()
	{
		s_memory_block * pos = v_root.v_next;
		while (1) {
			int flag = pos->flag;
			s_memory_block * tmp = pos->v_next;
			delete pos;
			pos = tmp;
			if (flag == v_fin_flag)
			{
				break;
			}
		}
	}
	int func_mem_create(int pagesize, size_t num = 200)
	{
		s_memory_block * pos = NULL;
		s_memory_block * smb = new s_memory_block(pagesize);
		v_root.v_next = smb; //the first 
		smb->flag = 0;
		pos = smb;
		for (int i = 1; i flag = i;
			pos->v_next = smb;
			pos = smb;
		}
		pos->v_next = v_root.v_next;
		//if (v_w == NULL)
		v_w = &v_root;
		v_r = &v_root;
		v_fin_flag = num - 1;
		return 0;
	}



	s_memory  *func_mem_write_get()
	{
		while (1)
		{
			if (v_w->v_next->v_lock != en_read) //en_middle ,en_write all can write
			{
				size_t pack_num = v_w->v_pack_num;
				v_w = v_w->v_next;
				v_w->v_lock = en_write;
				v_w->v_pack_num = pack_num +1;
				return v_w;
			}
			else {
				//give up the left cpu time let read to do what to do
				std::this_thread::yield();
			}
		}
	}

	void func_mem_write_fin(s_memory * w)
	{
		w->v_lock = en_middle;
		//func_mem_read_get
	}
	s_memory * func_mem_read_get()
	{
		if (v_r->v_next->v_lock == en_middle)//en_middle can read , en_write can not read
		{
			v_r->v_next->v_lock = en_read;
			v_r = v_r->v_next;
			return v_r;
		}
		return NULL;
	}
	void func_mem_read_fin(s_memory *r)
	{
		r->v_lock = en_middle;
	}

};

未完待续。。。