Linux多线程与fork()函数

4.1多线程中使用进程复制

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
void* fun(void* arg)
{
    for(int i=0;i<5;++i)
    {
        printf("fun run pid=%d\n",getpid());
    	sleep(1);
    }
}
int main()
{
    pthread_t id;
    pthread_create(&id,NULL,fun,NULL);
    fork();//
    for(int i=0;i<5;++i)
    {
        printf("main run pid=%d\n",getpid());
        sleep(1);
    }
    pthread_join(id,NULL);
    exit(0);
}

在使用fork()函数之后，没有判断返回值大于0还是等于0，则之后的代码在父子进程都会执行。

 

pid相同的为父进程中的两个线程，pid不同的为子进程的线程。此时子进程启动的为父进程的主线程所在的执行路径。

当把fork()从主线程中放到子线程中时：

void* fun(void* arg)
{
    fork();//
    for(int i=0;i<5;++i)
    {
        printf("fun run pid=%d\n",getpid());
    	sleep(1);
    }
}
int main()
{
    pthread_t id;
    pthread_create(&id,NULL,fun,NULL);
    for(int i=0;i<5;++i)
    {
        printf("main run pid=%d\n",getpid());
        sleep(1);
    }
    pthread_join(id,NULL);
    exit(0);
}

 

pid相同的为父进程中的两个线程，pid不同的为子进程的线程。此时子进程启动的为父进程的子线程所在的执行路径（线程）。

从上述两种情况能看到，在复制子进程时fork()函数父进程的资源状态等会全部复制过来，但是只有一条执行路径（线程），只会将fork()函数所在的执行路径（线程）进行复制。也就意味着，复制的子进程只有一条执行路径（线程），该路径是父进程中fork()函数所在的路径（线程）。

4.2多线程中互斥锁与fork()函数

pthread_mutex_t mutex;
void* fun(void* arg)
{
    pthread_mutex_lock(&mutex);
    printf("theread fun lock\n");
    sleep(5);
    pthread_mutex_unlock(&mutex);
    printf("thread fun unlock\n");
}
int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_t id;
    pthread_create(&id,NULL,fun,NULL);
    sleep(1);
    pid_t pid=fork();
    if(pid==-1)
    {
        exit(1);
    }
    if(pid==0)
    {
        printf("child 准备加锁\n");
        pthread_mutex_lock(&mutex);
        printf("child 加锁成功\n");
        pthread_mutex_unlock(&mutex);
        exit(0);
    }
    wait(NULL);
    printf("main over\n");
    pthread_join(id,NULL);
    exit(0);
}

运行结果：

 

原因：父进程的子线程先加锁并打印加锁信息，等待五秒钟，此时子进程打印准备加锁后阻塞住，等到父进程的子线程解锁并打印信息后子进程依然在阻塞，没有加上锁，所以子进程和父进程用的不是同一个锁。子进程一直不能加锁，说明子进程的锁一直处于加锁状态没有解锁，在fork()之前睡眠一秒钟，这一秒钟足够父进程的子线程加锁，所以子进程在复制父进程时，将父进程的加锁状态复制过来。

当去掉上述代码中的sleep()语句后，复制子进程时，子进程的锁的状态就变成不确定随机的，因为是在启动父进程的子线程后才开始复制的，复制时可能子线程加锁还没解锁，也可能子进程加完锁又解开了。

为了避免这种子进程不确定锁的状态，需要在父进程中挑取一个没人加锁的状态进行进程的复制，可以在fork()前进行加锁，在fork()后再进行解锁。当如果多出使用fork()函数这样的方法比较繁杂，于是就使用函数pthread_atfork(父进程加锁函数，父进程解锁函数，子进程解锁函数)，当程序中使用fork()函数时，会先调用父进程加锁函数，然后在fork()结束后在父进程调用父进程解锁函数，然后在子进程中调用子进程解锁函数。

pthread_mutex_t mutex;
void fun_mutex_lock()
{
    pthread_mutex_lock(&mutex);
}
void fun_mutex_unlock()
{
    pthread_mutex_unlock(&mutex);
}
void child_mutex_unlock()
{
    pthread_mutex_unlock(&mutex);
}
void* fun(void* arg)
{
    pthread_mutex_lock(&mutex);
    printf("theread fun lock\n");
    sleep(5);
    pthread_mutex_unlock(&mutex);
    printf("thread fun unlock\n");
}
int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_atfork(fun_mutex_lock,fun_mutex_unlock,child_mutex_unlock);
    pthread_t id;
    pthread_create(&id,NULL,fun,NULL);
    sleep(1);
    pid_t pid=fork();
    if(pid==-1)
    {
        exit(1);
    }
    if(pid==0)
    {
        printf("child 准备加锁\n");
        pthread_mutex_lock(&mutex);
        printf("child 加锁成功\n");
        pthread_mutex_unlock(&mutex);
        exit(0);
    }
    wait(NULL);
    printf("main over\n");
    pthread_join(id,NULL);
    exit(0);
}