C語言實現環形緩衝區

1、簡述環形緩衝區可以把它的讀出端（以下簡稱R）和寫入端（以下簡稱W）想象成是兩個人在體育場跑道上追逐（R追W）。當R追上W的時候，就是緩衝區爲空；當W追上R的時候（W比R多跑一圈），就是緩衝區滿。

爲了形象起見，去找來一張圖並略作修改，如下：

2、環形緩衝區的實現原理 

環形緩衝區通常有一個讀指針和一個寫指針。讀指針指向環形緩衝區中可讀的數據，寫指針指向環形緩衝區中可寫的緩衝區。通過移動讀指針和寫指針就可以實現緩衝區的數據讀取和寫人。在通常情況下，環形緩衝區的讀用戶僅僅會影響讀指針，而寫用戶僅僅會影響寫指針。如果僅僅有一個讀用戶和一個寫用戶，那麼不需要添加互斥保護機制就可以保證數據的正確性。如果有多個讀寫用戶訪問環形緩衝區，那麼必須添加互斥保護機制來確保多個用戶互斥訪問環形緩衝區。

圖1、圖2和圖3是一個環形緩衝區的運行示意圖。圖1是環形緩衝區的初始狀態，可以看到讀指針和寫指針都指向第一個緩衝區處；圖2是向環形緩衝區中添加了一個數據後的情況，可以看到寫指針已經移動到數據塊2的位置，而讀指針沒有移動；圖3是環形緩衝區進行了讀取和添加後的狀態，可以看到環形緩衝區中已經添加了兩個數據，已經讀取了一個數據。

示例程序：

#ifndef KFIFO_HEADER_H	 
#define KFIFO_HEADER_H	

//判斷x是否是2的次方  
#define is_power_of_2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))  
//取a和b中最小值  
#define min(a, b) (((a) < (b)) ? (a) : (b))  
  
struct ring_buffer	
{  
	void		 *buffer;	  //緩衝區	
	uint32_t	 size;		 //大小  
	uint32_t	 in;		 //入口位置  
	uint32_t	   out; 	   //出口位置  
	pthread_mutex_t *f_lock;	//互斥鎖  
};	
  
//初始化緩衝區	
struct ring_buffer* ring_buffer_init(void *buffer, uint32_t size, pthread_mutex_t *f_lock)	
{  
	assert(buffer);  
	struct ring_buffer *ring_buf = NULL;  
	if (!is_power_of_2(size))  
	{  
		fprintf(stderr,"size must be power of 2.\n");  
		return ring_buf;  
	}  
	ring_buf = (struct ring_buffer *)malloc(sizeof(struct ring_buffer));  
	if (!ring_buf)	
	{  
		fprintf(stderr,"Failed to malloc memory,errno:%u,reason:%s",  
			errno, strerror(errno));  
		return ring_buf;  
	}  
	memset(ring_buf, 0, sizeof(struct ring_buffer));  
	ring_buf->buffer = buffer;	
	ring_buf->size = size;	
	ring_buf->in = 0;  
	ring_buf->out = 0;	
        ring_buf->f_lock = f_lock;	
	return ring_buf;  
}  
//釋放緩衝區  
void ring_buffer_free(struct ring_buffer *ring_buf)  
{  
	if (ring_buf)  
	{  
	if (ring_buf->buffer)  
	{  
		free(ring_buf->buffer);  
		ring_buf->buffer = NULL;  
	}  
	free(ring_buf);  
	ring_buf = NULL;  
	}  
}  
  
//緩衝區的長度	
uint32_t __ring_buffer_len(const struct ring_buffer *ring_buf)	
{  
	return (ring_buf->in - ring_buf->out);	
}  
  
//從緩衝區中取數據	
uint32_t __ring_buffer_get(struct ring_buffer *ring_buf, void * buffer, uint32_t size)	
{  
	assert(ring_buf || buffer);  
	uint32_t len = 0;  
	size  = min(size, ring_buf->in - ring_buf->out);		  
	/* first get the data from fifo->out until the end of the buffer */  
	len = min(size, ring_buf->size - (ring_buf->out & (ring_buf->size - 1)));  
	memcpy(buffer, ring_buf->buffer + (ring_buf->out & (ring_buf->size - 1)), len);  
	/* then get the rest (if any) from the beginning of the buffer */  
	memcpy(buffer + len, ring_buf->buffer, size - len);  
	ring_buf->out += size;	
	return size;  
}  

//從緩衝區丟棄數據
uint32_t __ring_buffer_throw(struct ring_buffer *ring_buf, uint32_t size)	
{  
	assert(ring_buf);  
	uint32_t len = 0;  
	size  = min(size, ring_buf->in - ring_buf->out);		  
	ring_buf->out += size;	
	return size;  
}  



//向緩衝區中存放數據  
uint32_t __ring_buffer_put(struct ring_buffer *ring_buf, void *buffer, uint32_t size)  
{  
	assert(ring_buf || buffer);  
	uint32_t len = 0;  
	size = min(size, ring_buf->size - ring_buf->in + ring_buf->out);  
	/* first put the data starting from fifo->in to buffer end */  
	len  = min(size, ring_buf->size - (ring_buf->in & (ring_buf->size - 1)));  
	memcpy(ring_buf->buffer + (ring_buf->in & (ring_buf->size - 1)), buffer, len);	
	/* then put the rest (if any) at the beginning of the buffer */  
	memcpy(ring_buf->buffer, buffer + len, size - len);  
	ring_buf->in += size;  
	return size;  
}  
  
uint32_t ring_buffer_len(const struct ring_buffer *ring_buf)  
{  
	uint32_t len = 0;  
	pthread_mutex_lock(ring_buf->f_lock);  
	len = __ring_buffer_len(ring_buf);	
	pthread_mutex_unlock(ring_buf->f_lock);  
	return len;  
}  
  
uint32_t ring_buffer_get(struct ring_buffer *ring_buf, void *buffer, uint32_t size)  
{  
	uint32_t ret;  
	pthread_mutex_lock(ring_buf->f_lock);  
	ret = __ring_buffer_get(ring_buf, buffer, size);  
	//buffer中沒有數據	
	if (ring_buf->in == ring_buf->out)	
	ring_buf->in = ring_buf->out = 0;  
	pthread_mutex_unlock(ring_buf->f_lock);  
	return ret;  
}  

uint32_t ring_buffer_throw(struct ring_buffer *ring_buf, uint32_t size)  
{  
	uint32_t ret;  
	pthread_mutex_lock(ring_buf->f_lock);  
	ret = __ring_buffer_throw(ring_buf, size);  
	//buffer中沒有數據	
	if (ring_buf->in == ring_buf->out)	
	ring_buf->in = ring_buf->out = 0;  
	pthread_mutex_unlock(ring_buf->f_lock);  
	return ret;  
}  

  
uint32_t ring_buffer_put(struct ring_buffer *ring_buf, void *buffer, uint32_t size)  
{  
	uint32_t ret;  
	pthread_mutex_lock(ring_buf->f_lock);  
	ret = __ring_buffer_put(ring_buf, buffer, size);  
	pthread_mutex_unlock(ring_buf->f_lock);  
	return ret;  
}  
#endif