Multithreading 无信号量的产品用户消费者

我正在尝试使用没有semaphoere的线程来解决生产者-消费者问题。在我的客户端中，我创建了4个线程，2个用于生产者，2个用于消费者，每个线程发送M个生产/消费消息。这是我的客户代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <pthread.h>

#define BUFSIZE     4096
#define N 4
/*
**  Client
*/
int M = 10;
pthread_t threads[N];

char        buf[BUFSIZE];
char        *service;
char        *host = "localhost";
int     cc;
int     csock;
int consumed,produced;

void *connect_and_handle(void *msg){
    /*  Create the socket to the controller  */
    if ( ( csock = connectsock( host, service, "tcp" )) == 0 ) {
        fprintf( stderr, "Cannot connect to server.\n" );
        exit( -1 );
    }
    printf( "The server is ready, please start entering commands.\n" );
    fflush( stdout );

    //  Start the loop
    int k;
    //char msg[50];
    for (k=0;k<M;k++){
        strcpy(buf, msg);

        // Send to the server
        if ( write( csock, buf, strlen(buf) ) < 0 ) {
            fprintf( stderr, "client write failed: %s\n", strerror(errno) );
            exit( -1 );
        }
        if ( (cc = read( csock, buf, BUFSIZE )) <= 0 )
            break;
        buf[cc] = 0;
        printf( "Server replied: %s\n", buf );
    }
    close( csock );

    // exit thread
    pthread_exit(NULL);
}


int main( int argc, char *argv[] ){
    char *msg, *msg2;
    switch( argc ) {
        case    2:
            service = argv[1];
            break;
        case    3:
            host = argv[1];
            service = argv[2];
            break;
        default:
            fprintf( stderr, "usage: chat [host] port\n" );
            exit(-1);
    }
    // thread code goes here

    int i, n = N;
    for (i=0;i<N;i++){
        msg = (char*)malloc(32*sizeof(char));
        msg2 = (char*)malloc(32*sizeof(char));

        sprintf(msg,"PRODUCE This is the item #%i", i);
        sprintf(msg2, "CONSUME");
        //producer thread
        produced = pthread_create( &threads[i], NULL, connect_and_handle, (void *) msg );
        if ( produced != 0 ) { printf( "Error: pthread_create returned code %d.\n", produced); exit( -1 );}
        //consumer thread
        /*
        i++;

        consumed = pthread_create( &threads[i], NULL, connect_and_handle, (void *) msg2 );
        if ( consumed != 0 ){ printf( "Error: pthread_create returned code %d.\n", consumed ); exit( -1 );}
        */
    }
}

---

我正在退出，客户端和服务器中的控制台均未打印任何内容。

不相关，但'requestbuf[cc]='\0'；'如果读取已填满缓冲区，则将写入越界。'strcpy（buf，msg）；'不会编译，因为您注释掉了msg…的声明，这意味着'buf'未初始化，strlen（buf）为UB。请修复明显的问题，然后发布编译的代码（以及链接和生成）。

//  This server implements part of the 333 protocol
//  NUMBER  - number of clients served
//  NAMES   - developers
//  GOODBYE - close connection
//  ADD - increment
//  SUBTRACT- decrement
//
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <semaphore.h>

#define QLEN            5
#define BUFSIZE         4096
#define MAX 100
/*
**  This server ... is threaded
*/

// Function prototypes
int passivesock( char *, char *, int, int * );

void *handle_a_client( void *arg );

// Global variables are shared by the threads

int clients = 0;
char *buffer[MAX];
char *maloc_buf;
int count=0;
int full_count=0;
int empty_count=MAX;

int main( int argc, char *argv[] ) {
    char            *service;
    struct sockaddr_in  fsin;
    int         alen;
    int         msock;
    int         ssock;
    int         rport = 0;

    switch (argc) {
        case    1:
            // No args? let the OS choose a port and tell the user
            rport = 1;
            break;
        case    2:
            // User provides a port? then use it
            service = argv[1];
            break;
        default:
            fprintf( stderr, "usage: server [port]\n" );
            exit(-1);
    }

    msock = passivesock( service, "tcp", QLEN, &rport );
    if (rport) {
        //  Tell the user the selected port
        printf( "server: port %d\n", rport );   
        fflush( stdout );
    }


    // Keep accepting clients until you are killed
    for (;;) {
        int     ssock;
        pthread_t   pid;

        alen = sizeof(fsin);
        ssock = accept( msock, (struct sockaddr *)&fsin, &alen );
        if (ssock < 0) {
            fprintf( stderr, "accept: %s\n", strerror(errno) );
            exit(-1);
        }
        clients++;
        printf("connected , %i", clients);
        // Launch a thread to manage this client
        // YES, pid is getting overwritten each time, but it is unused
        pthread_create( &pid, NULL, handle_a_client, (void *) ssock );

    }
}

void *handle_a_client( void *arg ) {
    char    requestbuf[BUFSIZE];
    char    replybuf[BUFSIZE];
    int     ssock = (int) arg;
    int cc;

    for (;;) {
        if ( (cc = read( ssock, requestbuf, BUFSIZE )) <= 0 ) {
            printf( "The client has gone.\n");
            (void) close(ssock);
            pthread_exit(0);
            break;
        }
        else {
            // Remove the newline and null-terminate the string
            requestbuf[cc] = '\0';
            int size = cc-7;
            printf( "The client on %d says: %s\n", ssock, requestbuf );
            if ( strncasecmp( requestbuf, "goodbye", 7 ) == 0 ) {
                close( ssock );
                break;
            }
            else if ( strncasecmp( requestbuf, "PRODUCE", 7 ) == 0 ) {
                if (full_count == MAX){
                    strcpy(replybuf,"FULL\n");
                    write(ssock,replybuf,strlen(replybuf));
                }
                else {
                    maloc_buf=(char*) malloc((size)*sizeof(char));
                    strcpy(maloc_buf, (requestbuf+8));
                    buffer[full_count]=maloc_buf;
                    int num=full_count+1;
                    sprintf(replybuf, "Client produced item no%i: %s",full_count, buffer[full_count]);
                    full_count++;
                    empty_count--;
                }
            }
            else if ( strncasecmp( requestbuf, "CONSUME", 7 ) == 0 ) {
                if (empty_count == MAX) {
                    strcpy(replybuf,"EMPTY\n");
                    write( ssock, replybuf, strlen(replybuf) );
                }
                else {
                    sprintf(replybuf,"OK %s", buffer
                            [full_count]);
                    free(buffer[full_count]);
                    full_count--;
                    empty_count++;
                }
            }
        }
    }
}

if ( ( csock = connectsock( host, service, "tcp" )) == 0 ) {