Linux--线程安全、多线程fork问题
目录
一、概念：
二、利用空格分割字符串：
1.代码：
2.结果：
3.解决方法：
三、多线程fork（）
1.代码：
2.线程id
3.增加fork（）代码：
4.改变fork（）位置
5.运行结果
6.总结
四、父进程有锁，fork（）后子进程有锁吗
1.代码：
//运行结果
子进程为什么加不上锁？
//如何解决子进程被锁住？
一、概念：
线程安全：多线程无论调度顺序怎么样，都可以得到正确的结果（由并发线程引起）
同步：线程安全的函数，可重入函数
二、利用空格分割字符串：
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);
}
//结果
//父进程解锁之后才复制，所以子进程复制的锁也是处于解开的状态，所以子进程可以加锁再解锁成功，最后得到退出码，结束main程序