自己实现多线程环境下的pipe_windows的pipe原理多写一读-CSDN博客

本文链接：https://blog.csdn.net/qq_45826058/article/details/126670588

简介

实现一个用户可以自定义缓冲区大小的管道
管道可以根据缓冲区的数据长度对用户的读和写操作进行合理的处理
- 只有写端注册时，会等到读端打开时写端注册才会返回
- 缓冲区没有数据时，读端会阻塞只到条件满足
- 缓冲区写不进完整的数据时，写端也会阻塞只到条件满足

代码

mypipe.h

#ifndef MYPIPE_H__
#define MYPIPE_H__

#define PIPE_READ   0x00000001UL
#define PIPE_WRITE  0x00000002UL

typedef void Mypipe_t;

int mypipe_init(Mypipe_t **pipe, int pipe_size);

// 注册身份， opmap 为位图，支持与操作
int mypipe_register(Mypipe_t *pipe, u_int32_t opmap);

// 注销身份
int mypipe_unregister(Mypipe_t *pipe, u_int32_t opmap);

int mypipe_read(Mypipe_t *pipe, void *res, size_t size);

int mypipe_write(Mypipe_t *pipe, void *data, size_t size);

int mypipe_destroy(Mypipe_t *pipe);

#endif

mypipe.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <pthread.h>

#include "./mypipe.h"

typedef struct mypipe_st{

    char *data;
    int pipesize;
    int head;
    int tail;
    int datasize;

    int count_read;
    int count_write;

    pthread_mutex_t mutex;
    pthread_cond_t cond;

}mypipe_t;


int mypipe_init(Mypipe_t **pipe, int pipe_size){

    mypipe_t *me = NULL;
    me = (mypipe_t*)malloc(sizeof(*me));
    if(me == NULL){
        return -1;
    }

    me->pipesize = pipe_size;
    me->data = (char*)malloc(me->pipesize);
    if(me->data == NULL){
        return -1;
    }
    pthread_mutex_init(&me->mutex, NULL);
    pthread_cond_init(&me->cond, NULL);
#if 0
    pthread_mutex_t blank_mtx = PTHREAD_MUTEX_INITIALIZER;
    memcpy(&me->mutex, &blank_mtx, sizeof(blank_mtx));
    pthread_cond_t blank_cnd = PTHREAD_COND_INITIALIZER;
    memcpy(&me->cond, &blank_cnd, sizeof(blank_cnd));
#endif
    me->head = 0;
    me->tail = 0;
    me->count_read = 0;
    me->count_write = 0;
    me->datasize = 0;
    
    *pipe = me;

    return 0;
}


int mypipe_register(Mypipe_t *pipe, u_int32_t opmap){

    mypipe_t *me = pipe;


    pthread_mutex_lock(&me->mutex);

    if(opmap & PIPE_READ){
        me->count_read++;
    }
    if(opmap & PIPE_WRITE){
        me->count_write++;
    }

    pthread_cond_broadcast(&me->cond);

    while(me->count_read <= 0 || me->count_write <= 0){
        pthread_cond_wait(&me->cond, &me->mutex);
    }

    pthread_mutex_unlock(&me->mutex);

    return 0;
}

int mypipe_unregister(Mypipe_t *pipe, u_int32_t opmap){

    mypipe_t *me = pipe;

    pthread_mutex_lock(&me->mutex);
    if(opmap & PIPE_READ){
        me->count_read--;
    }
    if(opmap & PIPE_WRITE){
        me->count_write--;
    }
    pthread_cond_broadcast(&me->cond);
    pthread_mutex_unlock(&me->mutex);

    return 0;
}

static int get_next_idx(int idx, int max){

    return (idx + 1) % max;

}

static int mypipe_readbyte(mypipe_t *me, char *res){

    if(me->datasize <= 0){
        return -1;
    }

    *res = me->data[me->head];
    me->head = get_next_idx(me->head, me->pipesize);
    me->datasize--;

    return 0;
}

int mypipe_read(Mypipe_t *pipe, void *res, size_t size){

    mypipe_t *me = pipe;
    int i = 0;

    pthread_mutex_lock(&me->mutex);
    
    while(me->datasize <= 0 && me->count_write > 0){
        pthread_cond_wait(&me->cond, &me->mutex);
    }
    if(me->datasize <= 0 && me->count_write <= 0){
        pthread_mutex_unlock(&me->mutex);
        return 0;
    }

    for(i = 0; i < size; i++){
        if(mypipe_readbyte(me, res + i) != 0){
            break;
        }
    }

    pthread_cond_broadcast(&me->cond);

    pthread_mutex_unlock(&me->mutex);

    return i;
}

int mypipe_write(Mypipe_t *pipe, void *data, size_t size){

    mypipe_t *me = pipe;
    char *data_ = data;
    int i = 0;

    pthread_mutex_lock(&me->mutex);

    while(me->datasize + size > me->pipesize && me->count_read > 0){
        pthread_cond_wait(&me->cond, &me->mutex);
    }
    if(me->datasize + size > me->pipesize && me->count_read <= 0){
        pthread_mutex_unlock(&me->mutex);
        return -1;
    }

    while(i < size){
        me->data[me->tail] = data_[i];
        me->tail = get_next_idx(me->tail, me->pipesize);
        me->datasize++;
        i++;
    }

    pthread_cond_broadcast(&me->cond);

    pthread_mutex_unlock(&me->mutex);


    return 0;
}


int mypipe_destroy(Mypipe_t *pipe){

    mypipe_t *me = pipe;

    free(me->data);
    pthread_mutex_destroy(&me->mutex);
    pthread_cond_destroy(&me->cond);
    free(me);

    pipe = NULL;

    return 0;
}

test.c

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#include "./mypipe.h"

static void *my_func(void *arg){

    Mypipe_t *me = arg;

    puts("[read] register start.");
    mypipe_register(me, PIPE_READ);
    puts("[read] register finish.");

    char msg[1024];
    int len;
    u_int64_t count_ = 0;
    while(1){
        len = mypipe_read(me, msg, 10);
        count_ += len;
        // printf("len = %d\n", len);
        if(len == 0){
            break;
        }
        write(1, msg, len);
        fflush(stdout);
    }
    printf("total read %ld\n", count_);

    pthread_exit(NULL);
}

int main(){

    Mypipe_t *mypipe = NULL;
    int pipe_size = 1024;
    int ret = 0;

    ret = mypipe_init(&mypipe, pipe_size);
    if(ret){
        fprintf(stderr, "mypipe error\n");
        exit(1);
    }

    pthread_t tid;
    pthread_create(&tid, NULL, my_func, mypipe);
    pthread_create(&tid, NULL, my_func, mypipe);
    pthread_create(&tid, NULL, my_func, mypipe);

    puts("[write] register start.");
    mypipe_register(mypipe, PIPE_WRITE);
    puts("[write] register finish.");

    int i;
    u_int64_t count_ = 0;
    for(i = 0; i < 1024 * 1024; i++){
        ret = mypipe_write(mypipe, "saika-->saika\n", 15);
        count_ += 15;
        if(ret){
            puts("write error");
        }else{
            puts("write ok");
        }
    }

    puts("[write] unregister start.");
    mypipe_unregister(mypipe, PIPE_WRITE);
    puts("[write] unregister finish.");

    pthread_join(tid, NULL);

    
    printf("total write %ld\n", count_);

    mypipe_destroy(mypipe);

    exit(0);
}