创建线程，然后在临界区之前全部退出

Question

我需要为创建 8 个线程的类编写一个程序。 4个生产者，4个消费者。生产者需要循环，并随机发送 SIGUSR1 或 SIGUSR2 到所有消费者线程。如果他们收到了 SIGUSR1，则只有 2 个应该注册，另外 2 个注册 SIGUSR2。

当我尝试运行它时，所有线程都已创建，所有 4 个生产者线程都打印了“prod ready”，两个线程都打印了“waiting 1”，但是“waiting 2”打印了 3 次，然后所有线程都退出了。在调试结束时，它说进程正常退出。

我需要使用信号量来控制关键区域。任何帮助都会很棒。

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

#define NP  4
#define NC1 2
#define NC2 2
#define CNT 10

void handler1(int signum);
void handler2(int signum);

typedef struct {
    int sent;
    int received;
    int buf[1];   
    int SIG1;              
    int SIG2;              
    sem_t con;         
    sem_t prod;          
} sbuf_t;

sbuf_t buff;

void *producer() {
    printf("prod ready \n");
    int s;
    while(1){
        sem_wait(&buff.prod);
        s=rand()%2;
        if(s==1){
            buff.sent++;
            kill(0,SIGUSR1);
        }
        else if(s==2){
            buff.sent++;
            kill(0,SIGUSR2);

        }sem_post(&buff.prod);
    }

}

void *consumer1() {
    signal(SIGUSR1, handler1);
    printf("waiting 1\n");
    while(1){

    }
}

void *consumer2() {
    signal(SIGUSR2, handler2);
    printf("waiting 2\n");
    while(1){

    }
}

void handler1(int signum){
    if(signum==SIGUSR1){
        sem_wait(&buff.con);
        printf("Caught 1\n");
        buff.received++;
        buff.SIG1++;

        sem_post(&buff.con);
    }
}

void handler2(int signum){
    if(signum==SIGUSR2){
        sem_wait(&buff.con);
        printf("caught 2 \n");
        buff.received++;
        buff.SIG2++;

        sem_post(&buff.con);
    }
}

void main(){
    pthread_t threads[9];
    buff.SIG1=0;
    buff.SIG2=0;
    buff.sent=0;
    buff.received=0;
    int index;


        sem_init(&buff.con, 0, 0);
    sem_init(&buff.prod, 0, 0);
    for (index = 0; index < NP; index++) {
            pthread_create(&threads[index], NULL, producer,NULL);
        }
        for (index = 0;index < NC1;index++) {
            pthread_create(&threads[index+4], NULL, consumer1,NULL);
        }
    for (index = 0;index < NC2;index++) {
            pthread_create(&threads[index+6], NULL, consumer2,NULL);
        }
}

Answer 1

在main()函数中，正在创建线程，

然后main() 退出。

当 main() 退出时，所有线程也都退出。

建议阅读以下函数：pthread_exit() 和 pthread_join()

注意：以下在信号的处理和信号量的处理上有错误，但会演示pthread_join()和pthread_exit()的使用

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

#define NP  4
#define NC1 2
#define NC2 2
#define CNT 10

#define MAX_THREADS (9)

void handler1(int signum);
void handler2(int signum);

struct sbuf_t 
{
    int sent;
    int received;
    int buf[1];   
    int SIG1;              
    int SIG2;              
    sem_t con1;
    sem_t con2;         
    sem_t prod;          
};

typedef struct sbuf_t myData;
myData buff;

void *producer( void *dummy ) 
{
    (void)dummy;

    printf("prod ready \n");
    int s;

    while(1)
    {
        sem_wait(&buff.prod);
        s=rand()%2;

        if( !s )
        {
            buff.sent++;
            kill( 0, SIGUSR1 );
        }

        else // if( s )
        {
            buff.sent++;
            kill( 0, SIGUSR2 );
        }

        //sem_post(&buff.prod);
    }

    pthread_exit( NULL );
} // end thread: producer


void *consumer1( void *dummy ) 
{
    (void)dummy;

    //signal(SIGUSR1, handler1);
    printf("waiting 1\n");

    while(1)
    {
        sem_wait( &buff.con1 );
        // do something
        //sem_post( &buff.prod );
    }

    pthread_exit( NULL );
} // end thread: consumer1


void *consumer2( void *dummy ) 
{
    (void)dummy;

    //signal(SIGUSR2, handler2);
    printf("waiting 2\n");

    while(1)
    {
        sem_wait( &buff.con2 );
        // do something
        //sem_post( &buff.prod );
    }

    pthread_exit( NULL );
} // end thread: consumer2


void handler(int signum)
{
    sem_post(&buff.prod);
    if(signum==SIGUSR1)
    {
        //sem_wait(&buff.con);
        puts("Caught 1");
        buff.received++;
        buff.SIG1++;

        sem_post(&buff.con1);
    }

    else if(signum==SIGUSR2)
    {
        //sem_wait(&buff.con);
        puts("caught 2");
        buff.received++;
        buff.SIG2++;

        sem_post(&buff.con2);
    }
} // end signal handler: handler2


int main( void )
{
    pthread_t threads[ MAX_THREADS ];
    buff.SIG1=0;
    buff.SIG2=0;
    buff.sent=0;
    buff.received=0;
    int index;


    sem_init(&buff.con1, 0, 0);
    sem_init(&buff.con2, 0, 0);
    sem_init(&buff.prod, 0, 0);

    signal(SIGUSR2, handler);
    signal(SIGUSR1, handler);

    for (index = 0; index < NP; index++) 
    {
        pthread_create(&threads[index], NULL, producer,NULL);
    }

    for (index = 0;index < NC1;index++) 
    {
        pthread_create(&threads[index+4], NULL, consumer1,NULL);
    }

    for (index = 0;index < NC2;index++) 
    {
        pthread_create(&threads[index+6], NULL, consumer2,NULL);
    }

    for( size_t x=0; x<MAX_THREADS; x++ )
    {
        pthread_join( threads[x], NULL );
    }
} // end function: main

但是，处理线程信号的方法不使用kill()，因为那是用于进程的。

代码应该使用类似于:: 的函数

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
int pthread_cond_signal(pthread_cond_t *cond)

发出信号的线程应阻塞pthread_cond_wait() 调用，直到另一个线程使用pthread_cond_signal() 发送具有相同条件变量的信号。

考虑到将信号传递给进程的类比，这有点不同，因为信号线程已经暂停其执行以等待信号，这与简单地被中断并继续运行的进程不同。

Answer 2

例如，您是在消费者之前创建生产者。同样在您的生产者中，您正在使用随机数生成器来确定您是发布 USR1 还是 USR2。您的描述给人的印象是您想要每个两个（而不是一些随机混合总共 4 个），这就是我看到的代码为您所做的。