C语言第1章：队列queue实现

分享未结  0  466

李延 LV6 2022-05-12

悬赏：20积分

# 1 说明

通过自己写一个简单的队列，来练习c语言的多线程。

方便后续线程池中的使用

# 2 实现代码

## 2.1 queue.h

头文件 queue.h

```c
#ifndef QUEUE
#define QUEUE

#include <crtdefs.h>
#include <pthread.h>

typedef struct queue_attr_struct {

void *data; //存储内容
    struct queue_attr_struct *next;
    struct queue_attr_struct *head;
} queue_attr;

typedef struct queue_struct {
    size_t queue_size; // 当前队列长度,
    size_t max_num_thread; // 线程池核心运行数
    pthread_mutex_t queue_lock;     // execute_work 队列 lock
    queue_attr *execute_work_head;     // execute_work 队列 头
    queue_attr *execute_work_tail;     // execute_work 队列 尾

} queue;

void *queue_poll(queue *queue_t);

int queue_peek(queue *queue_t, void *work);

int queue_destroy(queue *queue_t);

queue *queue_create(size_t max_num_thread);
#endif

```

## 2.2 queue.c

队列queue的实现

```c
#include "queue.h"
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

/**
 * 队列出列
 * @param pool
 * @return
 */
void *queue_poll(queue *queue_t) {
    pthread_mutex_t lock = queue_t->queue_lock;

pthread_mutex_lock(&lock);

queue_attr *attr = queue_t->execute_work_head;
    if (attr == NULL) {
        pthread_mutex_unlock(&lock);
        return NULL;
    }

//队列头出列
    queue_t->execute_work_head = attr->next;
    queue_t->queue_size = queue_t->queue_size - 1;

if (queue_t->execute_work_head == NULL) {
        queue_t->execute_work_tail = NULL;
    }
    pthread_mutex_unlock(&lock);

void *data = attr->data;
    //销毁已出来元素
    free(attr);

return data;
}

/**
 * 队列入队
 * @param pool
 * @param work
 */
int queue_peek(queue *queue_t, void *data) {

pthread_mutex_t lock = queue_t->queue_lock;
    pthread_mutex_lock(&lock);
    if (queue_t->queue_size >= queue_t->max_num_thread) {
        printf("queue max!\n");
        return -1;
    }

queue_attr *attr = (queue_attr *) malloc(sizeof(queue_attr));
    attr->data = data;
    attr->next = NULL;
    queue_attr *old_attr = queue_t->execute_work_tail;
    //空队列,初始化
    if (old_attr == NULL) {
        attr->head = NULL;
        queue_t->execute_work_head = attr;
    } else {
        attr->head = old_attr;
        old_attr->next = attr;
    }
    queue_t->execute_work_tail = attr;
    queue_t->queue_size = queue_t->queue_size + 1;
    pthread_mutex_unlock(&lock);
    return 0;
}

queue *queue_create(size_t max_num_thread) {
    queue *queue_t = (queue *) malloc(sizeof(queue));
    queue_t->queue_size = 0;
    queue_t->execute_work_head = NULL;
    queue_t->execute_work_tail = NULL;
    queue_t->max_num_thread = max_num_thread;
    if (pthread_mutex_init(&queue_t->queue_lock, NULL) != 0) {
        exit(-1);
    }
    return queue_t;
}

int queue_destroy(queue *queue_t){
    if(queue_t->queue_size != 0){
        printf("queue has data!\n");
        return -1;
    }
    free(queue_t);
    return 0;
}

```

# 3 测试用例

```c
#include "../util/queue.h."
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *args[]) {
    queue *queue_t = queue_create(20);

for (int i = 0; i < 10000; i++) {
        int *i_t = (int *) malloc(sizeof(int ));
        *i_t = i;
        queue_peek(queue_t, i_t);
    }
    int *data = (int *)queue_poll(queue_t);
    while (data != NULL){
        printf("%d\n",*data);
        data = (int *)queue_poll(queue_t);
    }
    return 0;
}
```

回帖

消灭零回复