Question

如何在信号处理程序中正确销毁pthread互斥锁或rwlock？例如 - 在下面的代码中，我有主线程和3个另一个线程。所有线程使用互斥锁和锁在某些阵列上的无限循环中执行某些任务。因为主线程也在做一些任务，退出程序的唯一方法 - 使用信号处理程序。但是通过这种方式我无法破坏我的互斥锁/ rwlock对象，因为它无法保证对象被解锁。如果我尝试解锁它，当然一个线程会再次锁定它。当我试图再次启动我的程序时，打印损坏的结果。那么我该如何解决这个问题呢？我的代码有rwlocks的例子：

#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <signal.h>

#include <stdlib.h>

#include "thread_data.h"
#include "exchange_types.h"

pthread_rwlock_t rwlock;

unsigned int main_time   = 500000;
unsigned int shift_time  = 1000000;
unsigned int mirror_time = 2000000;
unsigned int count_time  = 4000000;

void signal_handler(int signo) {

    // Destroying locked lock or mutex is UB
    pthread_rwlock_destroy(&rwlock);
    exit(1);

}

void* shift_letter_case_async( void* array ) {

    while(1) {

        if( pthread_rwlock_rdlock(&rwlock) < 0 )
            handle_error("rdlock[shift]");

        carray_t* arr = (carray_t*) array;
        shift_letter_case( arr->array, arr->size );

        if( pthread_rwlock_unlock(&rwlock) < 0 )
            handle_error("unlock[shift]");

        usleep(shift_time);

    }

    return NULL;

}

void* mirror_array_async( void* array ) {

    while(1) {

        if( pthread_rwlock_rdlock(&rwlock) < 0 )
            handle_error("rdlock[mirror]");

        carray_t* arr = (carray_t*) array;
        mirror_array( arr->array, arr->size );

        if( pthread_rwlock_unlock(&rwlock) < 0 )
            handle_error("unlock[mirror]");

        usleep(mirror_time);

    }

    return NULL;

}

void* count_async( void* array ) {

    while(1) {

        if( pthread_rwlock_wrlock(&rwlock) < 0 )
            handle_error("wrlock[count]");

        carray_t* arr = (carray_t*) array;
        count_upper_letters( arr->array, arr->size );

        if( pthread_rwlock_unlock(&rwlock) < 0 )
            handle_error("unlock[count]");

        usleep(count_time);

    }

    return NULL;

}

int main( int argc, char** argv ) {

    /* Common data */
    char letters[ 'z' - 'a' + 1 ];
    size_t letter_len;
    carray_t transferer;
    /* pthread data */
    pthread_t threads[3];

    /* Initializing array */
    letter_len = sizeof(letters);
    for( int i = 0; i < letter_len; i++ )       
        letters[i] = 'a' + i;

    transferer.array = letters;
    transferer.size = letter_len;

    /* Initializing signal handlers */
    if ( signal(SIGINT, signal_handler) == SIG_ERR )
        handle_error("signal[SIGINT]");
    if ( signal(SIGTERM, signal_handler) == SIG_ERR )
        handle_error("signal[SIGTERM]");

    /* Initializing locks */
    if( pthread_rwlock_init(&rwlock, NULL) < 0 )
        handle_error("pthread_rwlock_init");

    /* Initializing threads */
    if( pthread_create( &threads[0], NULL, shift_letter_case_async, &transferer ) != 0 )
        handle_error("phtread_create[shift_letter_case]");

    if( pthread_create( &threads[1], NULL, mirror_array_async, &transferer ) != 0 )
        handle_error("phtread_create[mirror_array]");

    if( pthread_create( &threads[2], NULL, count_async, &transferer ) != 0 )
        handle_error("phtread_create[count]");

    while(1) {      

        if( pthread_rwlock_wrlock(&rwlock) < 0 )
            handle_error("wrlock[main]");

        print_array(letters, letter_len);

        if( pthread_rwlock_unlock(&rwlock) < 0 )
            handle_error("unlock[main]");

        usleep(main_time);


    }

    return 0;

}

Answer 1

而不是您提出的非常危险的方法，考虑通过安排发送每个线程来关闭，每个线程通过执行有序关闭来响应。在这种情况下让主线程加入其他线程，以便它知道它们何时完成;然后它可以干净地拆除任何持久的同步结构，临时文件等。

或者，仅向主线程发出信号，并以正确同步的方式获取它 - 引发一个标志，其他线程将识别为关闭指令，然后按上述步骤继续（加入工作线程，然后拆掉）。

Answer 2

我认为我对此的第一次天真尝试是将线程的while（1）和main更改为while（运行），其中“running”定义为：

volatile int running = 1;

将signal_handler更改为：

void signal_handler(int signo) {
    running = 0;
}

您可以在main中返回之前正常加入线程。我没有这样做，所以我可能完全错了。此外，您可能希望为usleep函数设置“if（running）”谓词。

在信号处理程序中销毁pthread互斥锁/ rwlock

2 个答案: