Linux--线程安全、多线程fork问题

A steria.

已于 2023-03-27 20:06:51 修改

阅读量1k

点赞数 1

分类专栏：线程文章标签：开发语言 linux c++

于 2023-03-18 21:42:19 首次发布

本文链接：https://blog.csdn.net/m0_59052131/article/details/129641540

版权

线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

四、父进程有锁，fork（）后子进程有锁吗

一、概念：

线程安全：多线程无论调度顺序怎么样，都可以得到正确的结果（由并发线程引起）

同步：线程安全的函数，可重入函数

二、利用空格分割字符串：

1.代码：

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

void* fun(void* arg)
{
    char buff[]={"a b c d e f g h"};
    char* s=strtok(buff," ");
    while(s!=NULL)
    {   
        printf("fun s=%s\n",s);
        sleep(1);
        s=strtok(NULL," ");
    }   
}

int main()
{
    pthread_t id; 
    pthread_create(&id,NULL,fun,NULL);
    char arr[]="1 2 3 4 5 6 7 8";
    char* s=strtok(arr," ");
    while(s!=NULL)
    {   
        printf("main s=%s\n",s);
        sleep(1);
        s=strtok(NULL," ");
    }   
    pthread_join(id,NULL);
    exit(0);
}

2.结果：

//为什么会出现这种状况？

一个指针，只能记住一个位置，main在打印1之后睡眠一秒钟，回去找指针的时候，指针已经指向b了，所以fun和main同时打印buff,两个线程同时获取一个字母的时候，快的将空格改成\0,让线程误以为结束了，把指针赋空了，进程就结束了。

3.解决方法：

使用strtok_r(_r代表线程安全版本)

//代码

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

void* fun(void* arg)
{
    char buff[]={"a b c d e f g h"};
    char* ptr=NULL;
    char* s=strtok_r(buff," ",&ptr);
    while(s!=NULL)
    {   
        printf("fun s=%s\n",s);
        sleep(1);
        s=strtok_r(NULL," ",&ptr);//NULL的作用只是为了使得每次调用时，都不是从头开始，而是从上次调用时查找所停止的位置开始，
    }   
}

int main()
{
    pthread_t id; 
    pthread_create(&id,NULL,fun,NULL);
    char arr[]="1 2 3 4 5 6 7 8";
    char* ptr=NULL;
    char* s=strtok_r(arr," ",&ptr);
    while(s!=NULL)
    {   
        printf("main s=%s\n",s);
        sleep(1);
        s=strtok_r(NULL," ",&ptr);
    }   
    pthread_join(id,NULL);
    exit(0);
}

//运行结果

//安全

为什么NULL可以达到这个作用？
答：strtok里面有静态变量指针，会记住分割到哪里，传空就是沿着当前位置继续分割，如果不是空，那就分割你传进来的字符串

三、多线程fork（）

1.代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.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);
    for(int i=0;i<5;i++)
    {
        printf("main run pid=%d\n",getpid());
        sleep(1);
    }
}

2.线程id

ps -eLf

//主线程id作为整个进程的id， 2代表的有两个线程

3.增加fork（）代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.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);
    }
}

fork();//后面的代码在子进程执行还是父进程执行？

都执行

//运行结果

//pid=11622去哪了？

被线程消耗了，打印的进程id

4.改变fork（）位置

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

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);
    }   
}

5.运行结果

6.总结

当一个进程有多条执行路径，对他进行fork(),产生的子进程只有一条执行路径，被所在线程启用

四、父进程有锁，fork（）后子进程有锁吗

1.代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>
#include<sys/wait.h>

pthread_mutex_t mutex;

void* fun(void* arg)
{
    pthread_mutex_lock(&mutex);
    printf("fun lock\n");
    sleep(5);
    pthread_mutex_unlock(&mutex);
    printf("fun unlock\n");
}


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

    sleep(1);
    pid_t pid=fork();
    if(pid==-1)
    {
        exit(0);
    }
    if(pid==0)//在子进程中
    {
        printf("子进程将要加锁\n");
        pthread_mutex_lock(&mutex);
        printf("子进程加锁成功\n");
        pthread_mutex_unlock(&mutex);
    }
    else//在父进程中
    {
        wait(NULL);//等待子进程结束，如果子进程没有结束，那么会阻塞
        printf("main over\n");
    }
    exit(0);
}

//运行结果

//子进程加锁没成功，执行到加锁的地方，父进程加锁解锁完成执行在wait

子进程为什么加不上锁？

//二次加锁，证明父进程加锁时，fork（）也有锁，即就是fork（）后有两个锁

如果是一个锁，可以加锁成功

fork（）时，父进程的锁是什么状态，子进程复制出来的锁就是什么状态

//如何解决子进程被锁住？

不可以把锁删掉（存在临界资源等问题）

选择没人用锁的时候进行（直接加锁，验证锁处于什么状态，加锁成功，再解锁）

但是如果别人正在用，那么会堵塞一段时间（锁住的时间）

//代码

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>
#include<sys/wait.h>

pthread_mutex_t mutex;

void* fun(void* arg)
{
    pthread_mutex_lock(&mutex);
    printf("fun lock\n");
    sleep(5);
    pthread_mutex_unlock(&mutex);
    printf("fun unlock\n");
}

void at_lock(void)
{
    pthread_mutex_lock(&mutex);
}
void at_unlock(void)
{
    pthread_mutex_unlock(&mutex);
}


int main()
{

    pthread_t id;
    pthread_atfork(at_lock,at_unlock,at_unlock);
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&id,NULL,fun,NULL);

    sleep(1);
    pid_t pid=fork();
    if(pid==-1)
    {
        exit(0);
    }
    if(pid==0)//在子进程中
    {
        printf("子进程将要加锁\n");
        pthread_mutex_lock(&mutex);
        printf("子进程加锁成功\n");
        pthread_mutex_unlock(&mutex);
    }
    else//在父进程中
    {
        wait(NULL);//等待子进程结束，如果子进程没有结束，那么会阻塞
        printf("main over\n");
    }
    exit(0);
}

//结果