Linux上目前有两种事件通知方式,一种是线程条件变量,一种是利用eventfd实现事件通知,下面介绍一下利用这两种方法实现异步队列的方法。
如果线程未持有与条件相关联的互斥锁,则调用 pthread_cond_signal() 或 pthread_cond_broadcast() 会产生唤醒丢失错误。满足以下所有条件时,即会出现唤醒丢失问题:
信号不起作用,因此将会丢失,仅当修改所测试的条件但未持有与之相关联的互斥锁时,才会出现此问题。只要仅在持有关联的互斥锁同时修改所测试的条件,即可调用 pthread_cond_signal() 和 pthread_cond_broadcast(),而无论这些函数是否持有关联的互斥锁。
get_resources(int amount)
{
pthread_mutex_lock(&rsrc_lock);
while (resources < amount)
{
pthread_cond_wait(&rsrc_add, &rsrc_lock);
}
resources -= amount;
pthread_mutex_unlock(&rsrc_lock);
}
add_resources(int amount)
{
pthread_mutex_lock(&rsrc_lock);
resources += amount;
pthread_cond_broadcast(&rsrc_add);
pthread_mutex_unlock(&rsrc_lock);
}
int eventfd(unsigned int initval, int flags);
eventfd
是Linux提供内核态的事件等待/通知机制,内核维护了一个8字节的整型数,该整型数由initval
来初始化,flags
参数可以由以下值位或而来:
O_CLOEXEC
标志。read
模式会使整型数减1并返回数值1。当内核维护的8字节整型数为0时,read
操作会阻塞,如果为fd设置为非阻塞模式,则返回EAGAIN
错误。
下面我们实现一个简单的环形队列:
#define default_size 1024
typedef struct queue
{
int header;
int tail;
int size;
int capcity;
void **_buf;
} queue_t;
queue_t *queue_create(int size)
{
queue_t *q = malloc(sizeof (queue_t));
if (q != NULL)
{
if (size > 0)
{
q->_buf = malloc(size);
q->capcity = size;
}
else
{
q->_buf = malloc(default_size * sizeof (void *));
q->capcity = default_size;
}
q->header = q->tail = q->size = 0;
}
return q;
}
int queue_is_full(queue_t *q)
{
return q->size == q->capcity;
}
int queue_is_empty(queue_t *q)
{
return q->size == 0;
}
void queue_push_tail(queue_t *q, void *data)
{
if (!queue_is_full(q))
{
q->_buf[q->tail] = data;
q->tail = (q->tail + 1) % q->capcity;
q->size++;
}
}
void *queue_pop_head(queue_t *q)
{
void *data = NULL;
if (!queue_is_empty(q))
{
data = q->_buf[(q->header)];
q->header = (q->header + 1) % q->capcity;
q->size--;
}
return data;
}
int *queue_free(queue_t *q)
{
free(q->_buf);
free(q);
}
typedef struct async_queue
{
pthread_mutex_t mutex;
pthread_cond_t cond;
int waiting_threads;
queue_t *_queue;
} async_queue_t;
async_queue_t *async_queue_create(int size)
{
async_queue_t *q = malloc(sizeof (async_queue_t));
q->_queue = queue_create(size);
q->waiting_threads = 0;
pthread_mutex_init(&(q->mutex), NULL);
pthread_cond_init(&(q->cond), NULL);
return q;
}
void async_queue_push_tail(async_queue_t *q, void *data)
{
if (!queue_is_full(q->_queue))
{
pthread_mutex_lock(&(q->mutex));
queue_push_tail(q->_queue, data);
if (q->waiting_threads > 0)
{
pthread_cond_signal(&(q->cond));
}
pthread_mutex_unlock(&(q->mutex));
}
}
void *async_queue_pop_head(async_queue_t *q, struct timeval *tv)
{
void *retval = NULL;
pthread_mutex_lock(&(q->mutex));
if (queue_is_empty(q->_queue))
{
q->waiting_threads++;
while (queue_is_empty(q->_queue))
{
pthread_cond_wait(&(q->cond), &(q->mutex));
}
q->waiting_threads--;
}
retval = queue_pop_head(q->_queue);
pthread_mutex_unlock(&(q->mutex));
return retval;
}
void async_queue_free(async_queue_t *q)
{
queue_free(q->_queue);
pthread_cond_destroy(&(q->cond));
pthread_mutex_destroy(&(q->mutex));
free(q);
}
typedef struct async_queue
{
int efd; //event fd
fd_set rdfds; //for select
queue_t *_queue;
} async_queue_t;
async_queue_t *async_queue_create(int size)
{
async_queue_t *q = malloc(sizeof (async_queue_t));
q->efd = eventfd(0, EFD_SEMAPHORE|EFD_NONBLOCK);
q->_queue = queue_create(size);
FD_ZERO(&(q->rdfds));
FD_SET(q->efd, &(q->rdfds));
return q;
}
void async_queue_push_tail(async_queue_t *q, void *data)
{
unsigned long long i = 1;
if (!queue_is_full(q->_queue))
{
queue_push_tail(q->_queue, data);
write(q->efd, &i, sizeof (i));
}
}
void *async_queue_pop_head(async_queue_t *q, struct timeval *tv)
{
unsigned long long i = 0;
void *data = NULL;
if (select(q->efd + 1, &(q->rdfds), NULL, NULL, tv) == 0)
{
return data;
}
else
{
read(q->efd, &i, sizeof (i));
return queue_pop_head(q->_queue);
}
}
void async_queue_free(async_queue_t *q)
{
queue_free(q->_queue);
close(q->efd);
free(q);
}
两种实现方法线程条件变量比较复杂,但是性能略高,而eventfd实现简单,但是性能略低。