线程与进程， 线程与信号

线程与进程

fork子进程如何复制多线程的父进程？

考虑一个问题：父进程在fork之前，已经创建了多个线程，那么再调用fork，新建子进程具有和父进程同样数量的线程吗？是否会复制父进程的所有线程？

答案是否定的。 fork子进程只会复制调用fork的线程，不会复制父进程的其他线程。既然是复制，因而子进程会自动继承父进程中的互斥锁（条件变量、信号量）的状态。i.e. 如果互斥量在父进程中被上锁，到子进程也会被上锁。

然而，子进程并不清楚从父进程继承来的互斥量具体的锁状态，因为是复制的线程。互斥量有可能加锁，有可能解锁。如果已经加锁，子进程再次加锁，会导致永远无法解锁（死锁）。

如下面的例子，子进程处于死锁状态

/**
 * 线程与进程示例程序
 * fork子进程只会复制调用fork的执行线程，并不会复制父进程其他子线程。子进程自动>继承父进程中互斥锁（条件变量/信号量）的状态。父进程中已经加锁的互斥锁，子进程也>会被锁住
 */
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t mutex;

/* 父进程调用，会锁住父进程中的mutex*/
void *another(void *arg)
{
    printf("in child thread, lock the mutex
");
    pthread_mutex_lock(&mutex);
    sleep(5);
    pthread_mutex_unlock(&mutex);
}

int main()
{

    pthread_mutex_init(&mutex, NULL);
    pthread_t id;
    pthread_create(&id, NULL, another, NULL);

    /* 父进程中的主线程暂停1s，以确保在执行fork前子线程已经开始运行并获得互斥量mutex */
    sleep(1);
    int pid;

    /* 由于前面已经sleep 1S，fork时互斥量mutex已经加锁，fork复制调用线程的锁状态，也是加锁的 */
    if ((pid = fork()) < 0) {
        perror("fork error");
        pthread_join(id, NULL);
        pthread_mutex_destroy(&mutex);
        return 1;
    }
    else if (pid == 0) { /* child */
        printf("i am in the child, want to get the lock
");

        /* 子进程从父进程继承来互斥锁mutex的状态，该互斥锁处于锁住状态，这是由父进程中的子线程执>行pthread_mutex_lock引起的。因此下面语句会导致子进程一直阻塞，而从逻辑上来说，虽然单独的子进程不>应该是阻塞的 */
        pthread_mutex_lock(&mutex);
        printf("I cannot run to here, oop...
");
        pthread_mutex_unlock(&mutex);
        exit(0);
    }
    else { /* parent */
        wait(NULL);
    }
    pthread_join(id, NULL);
    pthread_mutex_destroy(&mutex);

    return 0;
}

pthread_atfork 清理多线程父进程锁状态

如何解决fork子进程继承父进程锁状态导致的死锁问题？
之前这篇文章Linux 系统编程学习笔记 - 线程，有提到过pthread_atfork函数，可以建立3个fork句柄帮助清理互斥锁的状态，以确保fork调用之后父进程、子进程都有一个确定的锁状态。

pthread_atfork解决fork子进程锁状态问题，示例程序：

/**
 * 线程与进程示例程序
 * 利用pthread_atfork解决fork子进程继承父进程锁状态，而不清楚锁状态的问题
 */

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

pthread_mutex_t mutex;

/* 父进程调用，会锁住父进程中的mutex*/
void *another(void *arg)
{
    printf("in child thread, lock the mutex
");
    pthread_mutex_lock(&mutex);
    sleep(5);
    pthread_mutex_unlock(&mutex);
}

/* fork调用创建出子进程之前被执行，用来锁定父进程中所有的互斥锁 */
void prepare()
{
    pthread_mutex_lock(&mutex);
}

/* fork调用创建出子进程之后，释放父、子进程中被锁主的互斥锁 */
void infork()
{
    pthread_mutex_unlock(&mutex);
}

int main()
{
    pthread_mutex_init(&mutex, NULL);
    pthread_t id;
    pthread_create(&id, NULL, another, NULL);

    /* 父进程中的主线程暂停1s，以确保在执行fork前子线程已经开始运行并获得互斥量mutex */
    sleep(1);
    int pid;

    pthread_atfork(prepare, infork, infork);

    /* 由于前面已经sleep 1S，fork时互斥量mutex已经加锁，fork复制调用线程的锁状态，也是加锁的 */
    if ((pid = fork()) < 0) {
        perror("fork error");
        pthread_join(id, NULL);
        pthread_mutex_destroy(&mutex);
        return 1;
    }
    else if (pid == 0) { /* child */
        printf("i am in the child, want to get the lock
");

        /* 子进程从父进程继承来互斥锁mutex的状态，该互斥锁处于锁住状态，这是由父进程中的子线程执>行pthread_mutex_lock引起的。因此下面语句会导致子进程一直阻塞，而从逻辑上来说，虽然单独的子进程不>应该是阻塞的 */
        pthread_mutex_lock(&mutex);
        printf("I cannot run to here, oop...
");
        pthread_mutex_unlock(&mutex);
        exit(0);
    }
else { /* parent */
        wait(NULL);
    }

    pthread_join(id, NULL);
    pthread_mutex_destroy(&mutex);

    return 0;
}

---

线程与信号

线程的signal mask

每个线程都拥有自己独立的信号屏蔽字（signal mask），共享信号处理以及信号处理函数。
i.e. 线程可以选择是否屏蔽信号，但是捕获方式（SIG_DFL, SIG_IGN或捕获）是共享的，捕获函数也是共享的。

可以用sigprocmask设置进程的signal mask，如何设置线程的signal mask？
注：sigaction修改的是进程对应某个信号的捕获函数，以及处理信号期间的signal mask，而非任意情况下的signal mask。

线程使用pthread_sigmask设置线程的signal mask，sigwait阻塞线程等待指定信号并处理之。
参见Linux 系统编程学习笔记 - 线程

实例：一个线程处理所有信号

如果每个线程都单独处理信号，可能会有不同的信号处理方式，不同的signal mask，很容易导致逻辑错误。如果让一个专门的线程处理所有信号，如何实现？

步骤：
1）主线程创建出子线程之前，就调用pthread_sigmask设置好signal mask，屏蔽（阻塞）所有信号。这样，新建的所有子线程会自动继承这个signal mask，从而不会响应被屏蔽信号。

2）在某个线程中，调用sigwait等待信号并处理

注意：一旦使用sigwait，就不应该在外对应信号设置信号处理函数，因为程序接收到信号时，只能有一个起作用。

一个专门的线程处理指定信号示例

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

#define handle_error_en(en, msg) 
    do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

void *sig_thread(void *arg)
{
    sigset_t *set = (sigset_t *)arg;
    int s, sig;
    for (; ;) {
        /* 2. 调用sigwait等待信号 */
        s = sigwait(set, &sig);
        if (s != 0) {
            handle_error_en(s, "sigwait error");
        }
        printf("Signal handling thread got signal %d
", sig);
    }
}

int main()
{
    pthread_t thread;
    sigset_t set;
    int s;

    /* 1. 在主线程中设置signal mask */
    sigemptyset(&set);
    sigaddset(&set, SIGQUIT);
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGUSR1);
    s = pthread_sigmask(SIG_BLOCK, &set, NULL);
    if (s != 0)
        handle_error_en(s, "pthread_sigmask error");

    s = pthread_create(&thread, NULL, &sig_thread, (void *)&set);
    if (s != 0)
        handle_error_en(s, "pthread_create error");

    pause();
    return 0;
}

从运行结果，可以看到，即使线程也继承了main线程的signal mask屏蔽了信号，但是依然可以用sigwait接收到信号并处理之。