Ring Buffer 实现原理

╰半橙微兮° 2024-04-19 14:03 70阅读 0赞

#  #

消息队列的设计与实现

本文介绍了 GUI 系统中消息队列的设计与实现方法。

#### 简介 ####

消息驱动机制是 GUI 系统的基础，消息驱动的底层基础设施之一是消息队列，它是整个 GUI 系统运转中枢，本文介绍了一个基于环形队列的消息队列实现方法，给出了它的数据结构、主要操作流程和核心代码。

#### 环形队列 ####

环行队列是一种首尾相连的队列数据结构，遵循先进先出原则，如下图所示：

<table> 
 <tbody> 
  <tr> 
   <td><img alt="ring buffer 示意图" src="http://image27.360doc.com/DownloadImg/2011/04/2710/11263291_1.gif"></td> 
  </tr> 
  <tr> 
   <td><span style="font-size:12px;">ring buffer 示意图</span></td> 
  </tr> 
 </tbody> 
</table>

在环形队列中用一组连续地址的存储单元依次存放从队列头到队列尾的元素，通过两个指针 read\_pos 和 write\_pos 分别指向读取位置和写入位置。

初始化队列时，令 read\_pos = write\_pos = 0，每当写入一个新元素时， write\_pos 增 1；每当读取一个元素时，read\_pos 增 1 。若队列已满，不能往队列写入数据；若队列为空，则不能读取数据。判断对列是否为满的的方法是看 (write\_pos + 1)% QUEUE\_SIZE == read\_pos 是否成立，判断队列是否为空的方法是看 write\_pos == read\_pos 是否成立。

鉴于多个线程同时访问环形队列，需要考虑线程之间的互斥和同步问题，拟采用锁控制多个线程互斥访问环形队列，使用信号量控制线程之间的同步。

一段时间内只能有一个线程获得锁，当它持有锁时，其它线程要访问环形队列必须等待，直到前者释放锁。由此，锁可以保证多个线程互斥的访问环形队列。

线程从队列对数据前首先判断信号量是否大于 1 ，若是，则从队列读数据；否则，进入等待状态，直到信号量大于 1 为止；线程往队列写入一个数据后，会将信号量增 1 ，若有线程在等待，则会被唤醒。由此，信号量实现了多线程同步访问环形队列。

#### 流程图 ####

下图是环形缓冲区的初始化、读数据、写数据的主要流程。

<table> 
 <tbody> 
  <tr> 
   <td><img alt="ring buffer 流程图" src="http://image27.360doc.com/DownloadImg/2011/04/2710/11263291_2.gif"></td> 
  </tr> 
  <tr> 
   <td><span style="font-size:12px;">ring buffer 流程图</span></td> 
  </tr> 
 </tbody> 
</table>

初始化时为环形队列分配内存空间，并完成锁和信号量的初始化；   若往环形队列写数据，首先要获得锁， 若锁已被占用，则进入等待状态，否 则进一步去判断环形队列是否已满。若满了，则释放锁并返回；若队列未满，将 数据写入 write\_pos 位置，write\_pos 增 1，释放锁并将信号量增 1，表示 已写入一个数据；   若从环形队列读数据，首先判断信号量是否大于 1 ，若不是，则等待，否则 去获取锁，若锁已被占用，则等待，否则从 read\_pos 位置读取数据，将 read\_pos 增 1 ，释放锁，读取完毕。

#### 数据结构 ####

环形队列的数据结构如下所示：

typedef _MSG { int message; void* param; } MSG; typedef _MSGQUE { pthread_mutex_t lock; sem_t wait; MSG* msg; int size; int read_ops; int write_ops; } MSGQUEUE;

环形队列包括如下数据：

lock：互斥锁；   wait：信号量   msg：指向数据区的指针；   size：环形队列数据最大个数；   read\_ops：读取位置；   write\_ops：写入位置。

#### 队列初始化 ####

初始化主要完成三个任务：

为环形队列分配内存；     初始化互斥锁，用 pthread\_mutex\_init 完成；     初始化信号量，用 sem\_init 完成。

/* Create message queue */ _msg_queue = malloc (sizeof (MSGQUEUE)); /* init lock and sem */ pthread_mutex_init (&_msg_queue->lock, NULL); sem_init (&_msg_queue->wait, 0, 0); /* allocate message memory */ _msg_queue -> msg = malloc (sizeof(MSG) * nr_msg); _msg_queue -> size = nr_msg;

#### 写操作 ####

如上面的流程图介绍，写操作主要包括如下几步： - 获取锁；

判断队列是否已满；   若没满，将数据写入 write\_pos 处，将 write\_pos 增 1，并判断 write\_pos 是否越界；   释放锁，并将信号量增 1。

/* lock the message queue */ pthread_mutex_lock (_msg_queue->lock); /* check if the queue is full. */ if ((_msg_queue->write_pos + 1)% _msg_queue->size == _msg_queue->read_pos) { /* Message queue is full. */ pthread_mutex_unlock (_msg_queue->lock); return; } /* write a data to write_pos. */ _msg_queue -> msg [write_pos] = *msg; write_pos ++; /* check if write_pos if overflow. */ if (_msg_queue->write_pos >= _msg_queue->size) _msg_queue->write_pos = 0; /* release lock */ pthread_mutex_unlock (_msg_queue->lock); sem_post (_msg_queue->wait);

#### 读操作 ####

同理，读操作分如下几个步骤：

检查信号量；   获取锁；   判断队列是否为空；   若不为空，则读取 read\_ops 处的数据，将 read\_ops 增 1，并判断 read\_pos 是否越界；   并释放锁。

sem_wait (_msg_queue->wait); /* lock the message queue */ pthread_mutex_lock (_msg_queue->lock); /* check if queue is empty */ if (_msg_queue->read_pos != _msg_queue->write_pos) { msg = _msg_queue->msg + _msg_queue->read_pos; /* read a data and check if read_pos is overflow */ _msg_queue->read_pos ++; if (_msg_queue->read_pos >= _msg_queue->size) _msg_queue->read_pos = 0; return; } /* release lock*/ pthread_mutex_unlock (_msg_queue->lock);

#### 问题 ####

本文采用的环形队列是固定长度的，还可进一步改进，设计成可变长度的环 形队列；   本文的消息队列是“先进先出”原则，没有考虑带优先级的消息，但这种场 合是存在的；   本文重点介绍了消息队列的原理和实现，对于一个 GUI 程序来讲，还需要一 个消息循环与消息队列一起工作，消息循环将单独总结。

# \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ #

# C程序循环队列的基本思想及原理 #

**循环队列**  
一）定义  
为了克服顺序队列中假溢出，通常将一维数组queue\[0\]到q\[maxsize-1\]看成是一个首尾相接的圆环，即queue\[0\]与queue\[maxsize-1\]相接在一起。将这种形式的顺序队列称为循环队列 。  
若tail+1=maxsize,则令tail=0. 这样运算很不方便，可利用数学中的求模运算来实现。  
入队：tail=(tail+1) mod maxsize;squeue\[tail\]=x.  
出队：head=(head+1) mod maxsize.

二）循环队列的变化  
在循环队列中，若head=tail,则称为队空， 若(tail+1) mod maxsize=head, 则称为队满，这时，循环队列中能装入的元素个数为maxsize-1,即浪费一个存储单元，但是这样可以给操作带来较大方便。  
  
三）循环队列上五种运算实现  
1.进队列  
1）进队列算法  
（1）检查队列是否已满，若队满，则进行溢出错误处理；  
（2）将队尾指针后移一个位置（即加1），指向下一单元；  
（3）将新元素赋给队尾指针所指单元。  
2) 进队列实现程序  
int head=0,tail=0;  
int enqueue (elemtype queue\[\], elemtype x)  
\{ if ((tail+1)%maxsize = = head) return(1);  
else \{ tail=(tail+1)%maxsize;  
queue\[tail\]=x; return(0); \}  
\}  
2. 出队列  
1)出队列算法  
（1）检查队列是否为空，若队空，则进行下溢错误处理；  
（2）将队首指针后移一个位置（即加1）；  
（3）取队首元素的值。  
2) 出队列实现程序  
int head=0,tail=0;  
int dlqueue(elemtype queue\[ \],elemtype \*p\_x )  
\{ if (head= =tail) return(1);  
else \{ head =(head+1) % maxsize;  
\*p\_x=queue\[head\]\]; return(0);  
\}  
\}  
(3) 队列初始化  
head=tail=0;  
(4) 取队头元素（注意得到的应为头指针后面一个位置值）  
elemtype gethead(elemtype queue\[ \] )  
\{ if (head= =tail) return(null);  
else return (queue\[(head+1)%maxsize\]);  
\}  
(5) 判队列空否  
int empty(elemtype queue\[ \] )  
\{ if (head= =tail) reurn (1);  
else return (0); \}  
       
  
（1） 循环队列的基本操作  
    循环队列中进行出队、入队操作时，头尾指针仍要加1，朝前移动。只不过当头尾指针指向向量上界（QueueSize-1）时，其加1操作的结果是指向向量的下界0。这种循环意义下的加1操作可以描述为：  
**① 方法一：**  
    if(i+1==QueueSize) //i表示front或rear  
        i=0;  
    else  
        i++;  
  
**② 方法二--利用"模运算"**  
    i=(i+1)%QueueSize；  
  
（2） 循环队列边界条件处理  
    循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"还是"满"。 【[参见动画演示][Link 1]】  
    解决这个问题的方法至少有三种：  
① 另设一布尔变量以区别队列的空和满；  
② 少用一个元素的空间。约定入队前，测试尾指针在循环意义下加1后是否等于头指针，若相等则认为队满（注意：rear所指的单元始终为空）；  
③使用一个计数器记录队列中元素的总数（即队列长度）。  
  
（3） 循环队列的类型定义  
  
     \#define Queur Size 100   //应根据具体情况定义该值  
     typedef char Queue DataType;  //DataType的类型依赖于具体的应用  
     typedef Sturet\{               //头指针，队非空时指向队头元素  
           int front;              //尾指针，队非空时指向队尾元素的下一位置  
           int rear;               //计数器，记录队中元素总数  
           DataType data\[QueueSize\]  
     \}CirQueue;  
  
（4） 循环队列的基本运算  
用第三种方法，循环队列的六种基本运算：  
**① 置队空**  
      void InitQueue(CirQueue \*Q)  
      \{  
              Q->front=Q->rear=0;  
              Q->count=0;     //计数器置0  
       \}  
  
**② 判队空**  
       int QueueEmpty(CirQueue \*Q)  
       \{  
            return Q->count==0;  //队列无元素为空  
        \}  
**③ 判队满**  
int QueueFull(CirQueue \*Q)  
        \{  
            return Q->count==QueueSize;  //队中元素个数等于QueueSize时队满  
         \}  
**④ 入队**  
void EnQueue(CirQueuq \*Q,DataType x)  
         \{  
            if(QueueFull((Q))                    
                   Error("Queue overflow");     //队满上溢  
            Q->count ++;                        //队列元素个数加1  
            Q->data\[Q->rear\]=x;                 //新元素插入队尾  
            Q->rear=(Q->rear+1)%QueueSize;      //循环意义下将尾指针加1  
**⑤ 出队**  
DataType DeQueue(CirQueue \*Q)  
          \{  
              DataType temp;  
              if(QueueEmpty((Q))  
                   Error("Queue underflow");     //队空下溢  
              temp=Q->data\[Q->front\];  
         &nb

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

在通信程序中，经常使用环形缓冲区作为数据结构来存放通信中发送和接收的数据。环形缓冲区是一个先进先出的循环缓冲区，可以向通信程序提供对缓冲区的互斥访问。

1、环形缓冲区的实现原理

环形缓冲区通常有一个读指针和一个写指针。读指针指向环形缓冲区中可读的数据，写指针指向环形缓冲区中可写的缓冲区。通过移动读指针和写指针就可以实现缓冲区的数据读取和写入。在通常情况下，环形缓冲区的读用户仅仅会影响读指针，而写用户仅仅会影响写指针。如果仅仅有一个读用户和一个写用户，那么不需要添加互斥保护机制就可以保证数据的正确性。如果有多个读写用户访问环形缓冲区，那么必须添加互斥保护机制来确保多个用户互斥访问环形缓冲区。

图1、图2和图3是一个环形缓冲区的运行示意图。图1是环形缓冲区的初始状态，可以看到读指针和写指针都指向第一个缓冲区处；图2是向环形缓冲区中添加了一个数据后的情况，可以看到写指针已经移动到数据块2的位置，而读指针没有移动；图3是环形缓冲区进行了读取和添加后的状态，可以看到环形缓冲区中已经添加了两个数据，已经读取了一个数据。

个数据。![6ada8aadac6470b1faed50f4.jpg][]

2、实例：环形缓冲区的实现

环形缓冲区是数据通信程序中使用最为广泛的数据结构之一，下面的代码，实现了一个环形缓冲区：

/\*ringbuf .c\*/

＃include<stdio. h>

＃include<ctype. h>

\#define NMAX 8

int iput = 0; /\* 环形缓冲区的当前放入位置 \*/

int iget = 0; /\* 缓冲区的当前取出位置 \*/

int n = 0; /\* 环形缓冲区中的元素总数量 \*/

double buffer\[NMAX\];

/\* 环形缓冲区的地址编号计算函数，如果到达唤醒缓冲区的尾部，将绕回到头部。

环形缓冲区的有效地址编号为：0到(NMAX-1)

\*/

int addring (int i)

return (i+1) == NMAX ? 0 : i+1;

/\* 从环形缓冲区中取一个元素 \*/

double get（void）

int pos;

if (n>0)\{

Pos = iget;

iget = addring(iget);

n--;

return buffer\[pos\];

else \{

printf(“Buffer is empty\\n”);

return 0.0;

/\* 向环形缓冲区中放入一个元素\*/

void put(double z)

if (n<NMAX)\{

buffer\[iput\]=z;

iput = addring(iput);

n++;

else

printf(“Buffer is full\\n”);

int main\{void)

chat opera\[5\];

double z;

do \{

printf(“Please input p|g|e?”);

scanf(“%s”, &opera);

switch(tolower(opera\[0\]))\{

case ‘p’: /\* put \*/

printf(“Please input a float number?”);

scanf(“%lf”, &z);

put(z);

break;

case ‘g’: /\* get \*/

z = get();

printf(“%8.2f from Buffer\\n”, z);

break;

case ‘e’:

printf(“End\\n”);

break;

default:

printf(“%s - Operation command error! \\n”, opera);

\}/\* end switch \*/

\}while(opera\[0\] != ’e’);

return 0;

在CAN通信卡设备驱动程序中，为了增强CAN通信卡的通信能力、提高通信效率，根据CAN的特点，使用两级缓冲区结构，即直接面向CAN通信卡的收发缓 冲区和直接面向系统调用的接收帧缓冲区。 通讯中的收发缓冲区一般采用环形队列（或称为FIFO队列），使用环形的缓冲区可以使得读写并发执行，读进程和写进程可以采用“生产者和消费者”的模型来 访问缓冲区，从而方便了缓存的使用和管理。然而，环形缓冲区的执行效率并不高，每读一个字节之前，需要判断缓冲区是否为空，并且移动尾指针时需要进行“折行处理”（即当指针指到缓冲区内存的末尾时，需要新将其定向到缓冲区的首地址）；每写一个字节之前，需要判断缓区是否为，并且移动尾指针时同样需要进行“ 折行处理”。程序大部分的执行过程都是在处理个别极端的情况。只有小部分在进行实际有效的操作。这就是软件工程中所谓的“8比2”关系。结合CAN通讯实际情况，在本设计中对环形队列进行了改进，可以较大地提高数据的收发效率。 由于CAN通信卡上接收和发送缓冲器每次只接收一帧CAN数据，而且根据CAN的通讯协议，CAN控制器的发送数据由1个字节的标识符、一个字节的RTR 和DLC位及8个字节的数据区组成，共10个字节；接收缓冲器与之类似，也有10个字节的寄存器。所以CAN控制器收的数据是短小的定长帧（数据可以不满 8字节）。 于是，采用度为10字节的数据块业分配内存比较方便，即每次需要内存缓冲区时，直接分配10个字节，由于这10个字节的地址是线性的，故不需要进行“折行”处理。更重要的是，在向缓冲区中写数据时，只需要判断一次是否有空闲块并获取其块首指针就可以了，从而减少了重复性的条件判断，大大提高了程序的执行效率；同样在从缓冲队列中读取数据时，也是一次读取10字节的数据块，同样减少了重复性的条件判断。 在CAN卡驱动程序中采用如下所示的称为“Block\_Ring\_t”的数据结构作为收发数据的缓冲区：

typedef struct \{

long signature;

unsigned char \*head\_p;

unsigned char \*tail\_p;

unsigned char \*begin\_p;

unsigned char \*end\_p;

unsigned char buffer \[BLOCK\_RING\_BUFFER\_SIZE\];

int usedbytes;

\}Block\_Ring\_t;

该数据结构在通用的环形队列上增加了一个数据成员usedbytes，它表示当前缓冲区中有多少字节的空间被占用了。使用usedbytes，可以比较方 便地进行缓冲区满或空的判断。当usedbytes=0时，缓冲区空；当usedbytes=BLOCK\_RING\_BUFFER\_SIZE时，缓冲区 满。 本驱动程序除了收发缓冲区外，还有一个接收帧缓冲区，接收帧队列负责管理经Hilon A协议解包后得到的数据帧。由于有可能要同接收多个数据帧，而根据CAN总线遥通信协议，高优先级的报文将抢占总线，则有可能在接收一个低优先级且被分为 好几段发送的数据帧时，被一个优先级高的数据帧打断。这样会出现同时接收到多个数据帧中的数据包，因而需要有个接收队列对同时接收的数据帧进行管理。 当有新的数据包到来时，应根据addr(通讯地址)，mode（通讯方式），index（数据包的序号）来判断是否是新的数据帧。如果是，则开辟新的 frame\_node；否则如果已有相应的帧节点存地，则将数据附加到该帧的末尾；在插入数据的同时，应该检查接收包的序号是否正确，如不正确将丢弃这包 数据。 每次建立新的frame\_node时，需要向frame\_queue申请内存空间；当frame\_queue已满时，释放掉队首的节点（最早接收的但未完 成的帧）并返回该节点的指针。 当系统调用读取了接收帧后，释放该节点空间，使设备驱动程序可以重新使用该节点。

形缓冲区:环形缓冲队列学习

来源: 发布时间:星期四, 2008年9月25日 浏览:117次 评论:0

项目中需要线程之间共享一个缓冲FIFO队列，一个线程往队列中添数据，另一个线程取数据（经典的生产者-消费者问题）。开始考虑用STL的vector 容器, 但不需要随机访问，频繁的删除最前的元素引起内存移动，降低了效率。使用LinkList做队列的话，也需要频繁分配和释放结点内存。于是自己实现一个有 限大小的FIFO队列，直接采用数组进行环形读取。

队列的读写需要在外部进程线程同步（另外写了一个RWGuard类, 见另一文）

到项目的针对性简单性，实现了一个简单的环形缓冲队列，比STL的vector简单

PS: 第一次使用模板，原来类模板的定义要放在.h 文件中， 不然会出现连接错误。

template <class \_Type>  
class CShareQueue  
\{  
public:  
CShareQueue();  
CShareQueue(unsigned int bufsize);  
virtual ~CShareQueue();

\_Type pop\_front();  
bool push\_back( \_Type item);  
//返回容量  
unsigned int capacity() \{ //warning:需要外部数据一致性  
return m\_capacity;  
\}  
//返回当前个数  
unsigned int size() \{ //warning:需要外部数据一致性  
return m\_size;  
\}  
//是否满//warning: 需要外部控制数据一致性  
bool IsFull() \{  
return (m\_size >= m\_capacity);  
\}

bool IsEmpty() \{  
return (m\_size == 0);  
\}

protected:  
UINT m\_head;  
UINT m\_tail;  
UINT m\_size;  
UINT m\_capacity;  
\_Type \*pBuf;

\};

template <class \_Type>  
CShareQueue<\_Type>::CShareQueue() : m\_head(0), m\_tail(0), m\_size(0)  
\{  
pBuf = new \_Type\[512\];//默认512  
m\_capacity = 512;  
\}

template <class \_Type>  
CShareQueue<\_Type>::CShareQueue(unsigned int bufsize) : m\_head(0), m\_tail(0)  
\{  
if( bufsize > 512 || bufsize < 1)  
\{  
pBuf = new \_Type\[512\];  
m\_capacity = 512;  
\}  
else  
\{  
pBuf = new \_Type\[bufsize\];  
m\_capacity = bufsize;  
\}  
\}

template <class \_Type>  
CShareQueue<\_Type>::~CShareQueue()  
\{  
delete\[\] pBuf;  
pBuf = NULL;  
m\_head = m\_tail = m\_size = m\_capacity = 0;  
\}

//前面弹出一个元素  
template <class \_Type>  
\_Type CShareQueue<\_Type>::pop\_front()  
\{  
if( IsEmpty() )  
\{  
return NULL;  
\}  
\_Type itemtmp;  
itemtmp = pBuf\[m\_head\];  
m\_head = (m\_head + 1) % m\_capacity;  
\--m\_size;  
return itemtmp;

//从尾部加入队列  
template <class \_Type>  
bool CShareQueue<\_Type>::push\_back( \_Type item)  
\{  
if ( IsFull() )  
\{  
return FALSE;  
\}  
pBuf\[m\_tail\] = item;  
m\_tail = (m\_tail + 1) % m\_capacity;  
\++m\_size;  
return TRUE;  
\}

\#endif

转载于:https://my.oschina.net/alphajay/blog/36602

[Link 1]: http://ei.tjuci.edu.cn/ds/sjjg/DataStructure/DS/web/flashhtml/xunhuanduilie.htm
[6ada8aadac6470b1faed50f4.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/0b4939ac38494c7e8e7bdefe7fd9ccd6.jpg