C语言多线程_生产者与消费者模型_链式队列实现

关注

原创最新推荐文章于 2026-08-30 12:23:04 发布 762 阅读 AI 写同款· GEO 优化 ›

多线程实现生产者与消费者模式 生产者-消费者模式的简介：在实际的软件开发过程中，我们将产生数据的模块称为生产者，处理数据的模块成为消费者。但仅有这两者还不够成为一个生产者-消费者模式，还需要有一个缓冲区（一段内存区域）作为中介，生产者产生的数据放入缓冲区，消费者从缓冲区读取数据并处理。（注：上述所说的模块是广义的，可以是类，函数，线程，进程等）我们可以将这二者之间的关系图表示出来：总结：我们用3-2-1的方法来简单描述一个生产者 阅读详情

代码中有详细注释，详见readme.txt

这个主要是基于条件变量和互斥量来实现，如果缓存队列在没有满或者没有空的场景下，读写线程只需要在数据插入删除的时候持有锁，使用完释放锁就可以保证原子性。
当进入读写线程发现队列满或者空的时候，就需要使用条件变量把线程阻塞，并释放锁，当写线程插入数据后，就会发一个不空的信号去唤醒读线程。反之同理。

相关API

线程
pthread_create 传入线程id创建线程
pthread_join 主线程阻塞等待指定线程结束

初始化
pthread_mutex_init 初始化锁
pthread_cond_init 初始化条件变量

pthread_cond_wait 前要先加锁
pthread_cond_wait 内部会解锁，然后等待条件变量被其它线程激活
pthread_cond_wait 被激活后会再自动加锁

pthread_mutex_lock 加锁（读写线程用同一个锁）
pthread_mutex_unlock 解锁
pthread_cond_signal 发送信号

cmakelist

cmake_minimum_required(VERSION 3.17)
project(A)

set(CMAKE_CXX_STANDARD 14)


add_executable(A  fun.cpp final.cpp)
#add_executable(A queue.c)

find_package(Threads REQUIRED)
target_link_libraries(A Threads::Threads)

fun.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "final.h"
#include <unistd.h>
#include<pthread.h>


struct Queue *init_queue()
{
    struct Queue *queue=(struct Queue *)malloc(sizeof(struct Queue));
    if(!queue)
    {

        exit(1);
    }


    queue->front=(struct Node*)malloc(sizeof(struct Node));

    queue->front->next=NULL;
    queue->rear=queue->front;
    queue->len=0;
    queue->max_len=MAX_LEN;
    pthread_mutex_init(&queue->q_lock,NULL);
    pthread_cond_init(&queue->not_empty,NULL);
    pthread_cond_init(&queue->not_full,NULL);


    return queue;
}


void en_queue(struct Queue *q,void* data,size_t len)//向队列的尾部插入一个数据,请传入数据类型的长度
{

    pthread_mutex_lock(&q->q_lock);

    while(q->len==MAX_LEN)
    {
       // printf("this queue is full\n");//这句使用是可以注释掉，会等待读函数删掉后再继续写
        pthread_cond_wait(&q->not_full,&q->q_lock);

    }
    struct Node *newnode=(struct Node*)malloc(sizeof(struct Node));

       newnode->data=malloc(len);
    memcpy(newnode->data,data,len);


    newnode->next=NULL;
    q->rear->next=newnode;
    q->rear=newnode;
    q->len=q->len+1;

    pthread_cond_signal(&q->not_empty);
    pthread_mutex_unlock(&q->q_lock);
}
void de_queue(struct Queue *q)//删除头部一个节点和他的数据域
{
    pthread_mutex_lock(&q->q_lock);

    while(q->len==0)
    {
        printf("this queue is empty");
        pthread_cond_wait(&q->not_empty,&q->q_lock);
    }

    struct Node *newnode;

    newnode=q->front->next;


    q->front->next=newnode->next;
    if(q->rear==newnode)
        q->rear=q->front;
    free(newnode);
    q->len=q->len-1;

    pthread_cond_signal(&q->not_full);
    pthread_mutex_unlock(&q->q_lock);
    return ;
}

int read_queue_save(struct Queue *q,void * out_space,size_t size_len)//传入数据类型的大小  读取数据并且保存,
{

    pthread_mutex_lock(&q->q_lock);

 //   printf("q len is %d\n",q->len);
    while(q->len==0)
    {
  //      printf("this queue is empty\n");
        pthread_cond_wait(&q->not_empty,&q->q_lock);

    }


    struct Node *read_node;
    read_node=q->front->next;
    int i=0;
    if(read_node==NULL)
    {
        printf("this queue is empty\n");
        return -1;
    }

    memcpy(out_space,read_node->data,size_len);


 //   read_node=read_node->next;
    pthread_cond_signal(&q->not_empty);
    pthread_mutex_unlock(&q->q_lock);
    return 0;
}
int destroy_queue(struct Queue *q)
{
    while(q->front)
    {
        q->rear=q->front->next;
        free(q->front);
        q->front=q->rear;
    }
    printf("destroy_queue ok\n");
    return 0;
}

final.h

#ifndef _QUEUE_H_
#define _QUEUE_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#ifdef __cplusplus
extern "C"
{
#endif

#define MAX_LEN 100 //在这里定义数据的最大的长度

struct Node {
    void* data;
    // mytype data;
    struct Node *next;
};

struct Queue {
    struct Node *front;
    struct Node *rear;
    int len;
    int max_len;

    pthread_mutex_t q_lock;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;

};


struct Queue *init_queue();
void en_queue(struct Queue *q,void* data,size_t len);//向队列的尾部插入一个数据
void de_queue(struct Queue *q);//删除头部一个节点和他的数据域
int read_queue_save(struct Queue *q,void * out_space,size_t len);//读取数据并且保存在out_space，不删除
int create_pipe();
int destroy_queue(struct Queue *q);

#ifdef __cplusplus
}
#endif

#endif

final.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "final.h"
#include <unistd.h>

typedef struct DATA1{
int ID;
char sex[16];
char name[26];

}data1;//模拟数据来源

typedef struct DATA2{
    int ID;
    char sex[16];
    char name[26];
}data2;//模拟数据接收空间

struct parameter//用户可定义更多的参数
{
    int fd;
    struct Queue *q;
};

struct parameter *par1=new parameter;
int create_pipe()
{
    par1->q=init_queue();
    if(par1->q!=NULL)
    {
        par1->fd=1;
        return par1->fd;
    }
    else
    {
        par1->fd=-1;
        return par1->fd;
    }

}

void *write_fn_ky(void *arg)
{
    struct parameter *p=(parameter*)arg;
    data1 da1;
    strcpy(da1.sex,"man");
    strcpy(da1.name,"good morning");
    printf("1111\n");
    for(int i = 0 ;i < 1000000; i++)
    {
        da1.ID = i;
        en_queue(par1->q, (void *) &da1, sizeof(da1));
        sleep(1);//模拟的写数据频率
    //    printf("1111\n");

    }



    return ((void *)0);


}
void *read_fn_ky(void *arg)
{

    struct parameter *p=(parameter*)arg;
    data1 da2;
    while(1)
    {

        int i;
        sleep(1);//模拟的读数据的频率
        //i = pipe_read(fd, (void*)& da2 , sizeof(da2))
        //int e;
        i=read_queue_save(par1->q,(void*)& da2 , sizeof(da2));
        if(i == 0)
        {
            printf("read success ID = %d , sex = %s , name = %s\n",da2.ID,da2.sex,da2.name);
            de_queue(par1->q);
            //finish_del(fd);
        }
        else
        {
            printf("read error\n");
        }
    }
    return ((void *)0);

}
int main()
{

    int fd= create_pipe();
    if(fd<0)
    {
        printf("=========测试1功能一，创建失败===========\n");
        return  -1;
    }
    printf("=========测试2功能二，进行正常读写===========\n");

    pthread_t id_1;
    pthread_t id_2;
    int err1;
    int err2;

    err1=pthread_create(&id_1,NULL,write_fn_ky,(void *)par1);//若成功返回0
    if(err1!=0)
    {
        printf("create write_fn_ky error\n");
        exit(1);
    }

    err2=pthread_create(&id_2,NULL,read_fn_ky,(void *)par1);
    if(err2!=0)
    {
        printf("create read_fn_ky error\n");
        exit(1);
    }

    pthread_join(id_1,NULL);
    pthread_join(id_2,NULL);


}

readme.txt

author:KQZ
date:2020-10-28

本工程用cmakelist代替makelife的作用


//
fun.cpp中主要为队列读写功能的实现

struct Queue *init_queue();//初始化
void en_queue(struct Queue *q,void* data,size_t len);//向队列的尾部插入一个数据。
void de_queue(struct Queue *q);//删除头部一个节点和他的数据域
int read_queue_save(struct Queue *q,void * out_space,size_t len);//读取数据并且保存在out_space，不删除，这里设计的目的是为了数据处理失败时能够重新读取数据
int create_pipe();//初始化,返回fd
int destroy_queue(struct Queue *q);//销毁

//
final.cpp 主函数 测试实例
void *write_fn_ky(void *arg)//示例写函数
void *read_fn_ky(void *arg)//示例读函数

利用多线程中的互斥量和条件变量实现读写的原子性问题

用户可以通过改变宏定义来决定队列最大的长度#define MAX_LEN 100
用户可以通过改变write_fn_ky read_fn_ky 中的sleep()来模拟读写的频率
当队列满的时候，写函数会等待读函数发出pthread_cond_t not_full;
当队列空的时候，读函数会等待写函数发出pthread_cond_t not_empty;

//测试用例
typedef struct DATA1{
int ID;
char sex[16];
char name[26];

}data1;//模拟数据来源
typedef struct DATA2{
    int ID;
    char sex[16];
    char name[26];
}data2;//模拟数据接收空间