进程的一生：
execute：
exec族
用fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），
子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的
用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建
新进程，所以调用exec前后该进程的id并未改变。
其实有六种以exec开头的函数，统称exec函数：
vector
ls -l -i list
execl("/bin/ls","-l","-i",NULL);
execlp("ls","-l","-i",NULL);
#include <unistd.h>
int exec l(const char *path, const char *arg, ...);
int exec lp(const char *file, const char *arg, ...);
int exec le(const char *path, const char *arg,..., char * const envp[]);
int exec v(const char *path, char *const argv[]);
int exec vp(const char *file, char *const argv[]);
int exec vpe(const char *file, char *const argv[], char *const envp[]);
(1).带l vs 带 v
int execl (const char *path, const char *arg, ...); //list ...表示任何可变参数
int execv (const char *path, char *const argv[]);//vector ---数组
功能:
执行一个文件 (可执行文件 a.out / 1.sh )
image 映像/镜像
text|data|bss|堆 栈|环境变量及命令行参数 + pcb
用新进程的 镜像 替换 调用进程的 镜像 替换之后身份未变，还是bash的子进程
参数:
@path 要执行的文件的路径(包含可执行文件的名字)
eg:
ls
/bin/ls
@arg 表示 可执行文件的文件名 （命令）
ls
... 可变参数
ls -l /
最后写一个NULL 表示结束
返回值：成功不会返回，失败返回-1.
execl("/bin/ls","ls","-l","/",NULL);
区别:
在于，参数传递的方式不同，
l --- list ---参数逐个列举
eg：
execl("/bin/ls","ls","-l","/",NULL);
v ---vector --- 参数组织成 指针数组的形式
eg:
char *const arg[] = {"ls","-l","/",NULL};
execv("/bin/ls",arg);
(2). p vs e
int execl p (const char *file, const char *arg, ...);
int execv p (const char *file, char *const argv[]);
p --- path ->PATH (环境变量 --- 都是可执行文件的路径) // echo $PATH 查看环境变量
带p 表示可执行文件的寻找方式，是从系统的环境变量PATH中的路径下面去找
如何用execlp/execvp方式启动自己的程序。
将自己写的程序所在的路径，添加到系统的环境变量中即可。
export PATH=$PATH:/home/linux/2021-code/3month/2-proc/proc/exec //注意,先引用原有环境变量 再追加
int execl e (const char *path, const char *arg,..., char * const envp[]);
int execvp e(const char *file, char *const argv[] , char * const envp[]);
带e 表示的是可以给要执行的 新程序 传递需要的 环境变量
extern char **environ; //系统的环境变量信息 的指针数组的首地址
env 可以看环境变量
练习：
实现
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include <sys/wait.h>
int main(int argc, const char *argv[])
{
char s[100] = {0};
while(1)
{
printf("minishell$ ");
fgets(s,sizeof(s),stdin);
s[strlen(s) - 1] = '\0';
if(strncmp(s,"quit",4) == 0 || strncmp(s,"exit",4) == 0)
{
printf("-----exit-----\n");
return 0;
}
char *p[10] = {NULL};
int i = 0;
p[i] = strtok(s," ");
while(p[++i] = strtok(NULL," "))
;
pid_t pid = fork();
if(pid < 0)
{
perror("fork fail");
return -1;
}
if(pid > 0)
{
int status;
printf("father -----\n");
wait(NULL);
}
else if(pid == 0)
{
if(execvp(p[0],p) < 0);
{
perror("execvp fail");
return -1;
}
//exit(99);
}
}
return 0;
}进程的总结：
线程thread ：
并发量的问题（并发程度）
进程的特点：
a.父子进程的独立空间
b.
线程：
区别：
进程 -是资源分配的基本单位
线程 -系统调度的最小单位
线程是CPU执行的最下单位 //就是来干活的
线程是轻量级的进程，进程是重量级的进程--需要大量的资源的分配
线程不需要太多的资源
{
线程pid
程序计数器 （pc - process counter）
相关寄存器
栈的空间
}
进程是分配资源和调度执行的基本单位。
fork
分配资源 --- 进程 (获取系统系统资源)
调度执行 --- 线程 (侧重执行任务)
线程 因为 共享 进程的资源
避免了 大量资源的开辟
线程的创建效率 高于进程创建效率
线程的缺点
安全性较差，---
线程间的通信。 ---共享进程资源
关系：
1.线程是存在进程中的
2.线程共用的进行的各个段和相关资源
线程的函数：
NPTL（Native Posix Thread Library） 线程库
1.生命周期：
（1）线程的创建：
pthread_create
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
功能：该函数可以创建指定的一个线程。
参数：
@thread 线程id，需要实现定义并由该函数返回。
@attr 线程属性，一般是NULL，表示默认属性。(可结合性+分离属性)
@start_routine
指向指针函数的函数指针。
本质上是一个函数的名称即可。
称为回调函数,是线程的执行空间。
@arg 回调函数的参数，即参数3的指针函数参数。
返回值： 成功 0
失败 错误码
练习：创建两个子线程，同时操作1个变量，一个+1，一个+2
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <unistd.h>
//线程的执行函数 -回调函数
void * doSomething1(void *arg)
{
int i = 0;
int *p = arg;
while (1)
{
(*p)++;
printf("1 doSomething n = %d i = %d\n",*p,i++);
sleep(1);
}
return NULL;
}
void *doSomething2(void *arg)
{
int i = 0;
int *p = arg;
while (1)
{
printf("2 doSomething n = %d i = %d\n",(*p)+=2,i++);
sleep(1);
}
return NULL;
}
#define N 2
typedef void *(*threadF_t) (void*);
int main(int argc, const char *argv[])
{
int n = 10;
pthread_t tid[N]; //long
///threadF_t pFunc[] = {doSomething1,doSomething2,NULL};
int i = 0;
for (i = 0; i < N; ++i)
{
//int ret = pthread_create(&tid[i],NULL,pFunc[i],&n);
int ret = pthread_create(&tid[i],NULL,doSomething1,&n);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
}
#if 0
int ret = pthread_create(&tid1,NULL,doSomething1,&n);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
pthread_t tid2; //long
ret = pthread_create(&tid2,NULL,doSomething2,&n);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
#endif
//printf("tid = %ld\n",tid);
//while(1);
while (1)
{
printf("main n = %d\n",n);
sleep(1);
}
return 0;
}int pthread_attr_init
int pthread_attr_init(pthread_attr_t *attr);
功能：
@初始化一个attr的变量
参数：
@ attr，需要变量来接受初始值
返回：
0 成功，
非0 错误；
int pthread_attr_destroy
int pthread_attr_destroy(pthread_attr_t *attr);
功能：销毁attr变量。
参数： @attr，属性变量
返回：
0 成功，
非0 错误；
int pthread_attr_setdetachstate
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);（这个风险不大就是恨麻烦）
功能：把一个线程设置成相应的属性
参数：@attr，属性变量，有init函数初始化他。
@detachstate：有2个可选值
1、PTHREAD_CREATE_DETACHED 可分离 //设置好线程的初始状态，可分离就不用主线程去回收了
2、PTHREAD_CREATE_JOINABLE 可结合
设置分离属性。
返回值：成功 返回 0
失败 >0 ，以及错误号
int pthread_detach(pthread_t thread);
这个写在create下面，创建成功下面，但是也有风险，就怕分离前子线程执行完了，才去分离已经没用了，也可以直接放在子线程开头
功能，设置分离属性
参数，线程id号，填自己的id
设置为可分离状态时，主线程就可以干自己的事情，不用自己用join来回收（join能获得子线程的状态，关心其回收状态看无人机），由系统来回收
创建线程时就设置了初始状态可分离
（2）线程的执行：
回调函数------执行任务
（3）线程的结束：
线程的结束条件：
The new thread terminates in one of the following ways:
* It calls pthread_exit(3), //pthread_exit([status])
specifying an exit status value that is available to
another thread in the same process that calls pthread_join(3).
* It returns from start_routine(). //return
This is equivalent to calling pthread_exit(3) with
the value supplied in the return statement.
* It is canceled (see pthread_cancel(3)). //被取消
* Any of the threads in the process calls exit(3), //exit() --- 进程正常结束
or the main thread performs a return from main() .//main- return 意味着就是进程结束。
This causes the termination of all threads in the process.
结束的函数
pthread_exit()
void pthread_exit(void *retval); // 与return 的效果一致
功能：子线程自行退出
参数： retval 线程退出时候的返回状态，临死遗言。
返回值：无
//若在主线程中调用，表示主线程结束，但是，此时进程空间不销毁，直到，所有的子线程都结束只有，此时进程空间销毁。
pthread_exit(值所在空间得地址) 这个值可以是数字和字符串
pthread_join()
int pthread_join(pthread_t thread, void **retval);
void pthread_exit(void *retval); //退出时，将"要传递的退出的状态值"的地址 传递
int pthread_join(pthread_t thread, void **retval);//等待 接收 pthread_exit() 传递过来的 状态值的地址保存
pthread_exit pthread_join (类似exit和wait)
pthread_datach(tid)
int pthread_detach(pthread_t thread);
将线程分离，不用主线程来join了
pthread_cancel()
强制退出 ==》他杀 ==》主线程结束子线程
int pthread_cancel(pthread_t thread);
功能：请求结束一个线程
参数：thread 请求结束一个线程tid
返回值：成功 0
失败 -1；
若在主线程中调用来结束子线程，则需传入子线程的tid，若在子线程中调用来结束主线程也相同。
练习：用线程 无人机 回收线程
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
#include <stdlib.h>
#include<errno.h>
#include<pthread.h>
#define N 4
void *ctrl(void *arg)
{
int i = 0;
while(i < 3)
{
printf("---ctrl----\n");
sleep(1);
++i;
}
pthread_exit("ctrl");
}
void *video(void *arg)
{
int i = 0;
while(i < 4)
{
printf("---video----\n");
sleep(1);
++i;
}
pthread_exit("video");
}
void *trans(void *arg)
{
int i = 0;
while(i < 5)
{
printf("---trans----\n");
sleep(1);
++i;
}
pthread_exit("trans");
}
void *store(void *arg)
{
int i = 0;
while(i < 6)
{
printf("---store----\n");
sleep(1);
++i;
}
pthread_exit("store");
}
typedef void *(*threadF_t)(void *);
int main(int argc, const char *argv[])
{
pthread_t tid[N];
threadF_t pFunc[] = {ctrl,video,trans,store,NULL};
int i = 0;
for(;i < N;++i)
{
int ret = pthread_create(&tid[i],NULL,pFunc[i], NULL);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
//return -1;
exit(EXIT_FAILURE); //这个宏中的值是-1
}
}
void *retval;
int j = 0;
for(;j < N;++j)
{
pthread_join(tid[j],&retval);
printf("-----%s exit------\n",(char *)retval);
}
printf("----------------main----exit-----------------\n");
return 0;
}void pthread_cleanup_push(void (*routine)(void *)， void *arg);
功能：注册一个线程清理函数（第一个是调一个自己写的清理函数，里面可以写要销毁的东西，比如用来分离的属性，第二个是清理函数要传的参数）
参数， @routine，线程清理函数的入口
@arg，清理函数的参数。
返回值，无
void pthread_cleanup_pop(int execute);
功能：调用清理函数
@execute，
非0 执行清理函数
0，不执行清理
但是关闭就会触发如果它放在关闭后面，这时候0和1都没关系
返回值，无
这两个必须一起用他们的本质的宏，各自完成do{（clean_push）
所以这里面在预定义的时候会替换，注意一定要符合语法
}while的一半(clean_pop)
注：写了pthread_cleanup_push就必须写 pthread_cleanup_pop，否则会报错！。
触发方式： 以下方式都会触发cleanup
1.pthread_cleanup_pop(非零值)
2.pthread_cleanup_pop(0) // pthread_exit() 退出动作会导致 触发
pthread_exit(NULL)； //线程正常结束
pthread_cleanup_pop(0); //放在pthread_exit（）后，就算是0也会执行清理。
3.pthread_cancel();: // 线程异常结束 被其他线程结束时
为什么需要cleanup呢？
因为在初始化线程attr参数时，创建了一些资源，线程分离自己回收后，设置attr的资源也要需要清理，故要调用cleanup函数。
练习：
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
#include <stdlib.h>
#include<errno.h>
#include<pthread.h>
#define N 4
void *ctrl(void *arg)
{
int i = 0;
while(i < 5)
{
printf("---ctrl----\n");
sleep(1);
++i;
}
pthread_exit("ctrl");
}
void *video(void *arg)
{
int i = 0;
while(i < 5)
{
printf("---video----\n");
sleep(1);
++i;
}
pthread_exit("video");
}
void *trans(void *arg)
{
int i = 0;
while(i < 5)
{
printf("---trans----\n");
sleep(1);
++i;
}
pthread_exit("trans");
}
void *store(void *arg)
{
int i = 0;
while(i < 5)
{
printf("---store----\n");
sleep(1);
++i;
}
pthread_exit("store");
}
void cleanup(void *arg)
{
pthread_attr_destroy(arg);
printf("cleanup\n");
}
typedef void *(*threadF_t)(void *);
int main(int argc, const char *argv[])
{
pthread_t tid[N];
threadF_t pFunc[] = {ctrl,video,trans,store,NULL};
int i = 0;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
for(;i < N;++i)
{
int ret = pthread_create(&tid[i],&attr,pFunc[i], NULL); //创建线程时就设置好分离状态
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
//return -1;
exit(EXIT_FAILURE); //这个宏中的值是-1
}
//pthread_detach(tid[i]);
}
pthread_cleanup_push(cleanup,&attr);
while(1)
{
printf("----------------main----exit-----------------\n");
sleep(1);
}
pthread_cleanup_pop(0);
pthread_exit(NULL);
return 0;
}多线程的互斥机制
临界资源: 共享资源
临界区 : 一段代码区域(访问临界资源的那段代码)
原子操作: 要么不操作，要操作，一定是一次完整的操作。不能被打断。
概念：
互斥 ===》在多线程中对临界资源的排他性访问。
互斥机制 ===》互斥锁 ===》保证临界资源的访问控制。
框架：
定义互斥锁-》初始化锁-》加锁-》解锁-》销毁
1、定义：
pthread_mutex_t mutex;如果定义在main函数要传参，全局大家都能用
2、//初始化一把锁 pthread_mutex_init();
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *attr);
功能：
将已经定义好的互斥锁初始化。
参数：
@mutex 要初始化的互斥锁
@atrr
初始化的值，一般是NULL表示默认锁 //读写锁 ,自旋锁 （）
返回值：
成功 0
失败 非零
3、 //上锁 pthread_mutex_lock();
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：用指定的互斥锁开始加锁代码
加锁后的代码到解锁部分的代码属于原子操作，
在加锁期间其他进程/线程都不能操作该部分代码
如果该函数在执行的时候，mutex已经被其他部分
使用则代码阻塞。
参数： @mutex 用来给代码加锁的互斥锁
返回值：成功 0
失败 非零
4、//解锁 pthread_mutex_unlock();
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：将指定的互斥锁解锁。
解锁之后代码不再排他访问，一般加锁解锁同时出现。
参数：用来解锁的互斥锁
返回值：成功 0
失败 非零
5、//销毁一把锁 pthread_mutex_destroy();
代码示例：
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
int count;
pthread_mutex_t mutex;
void*doSth1(void *arg)
{
int i = 0;
while (i < 50000)
{
pthread_mutex_lock(&mutex);
int temp = count;
printf("count 1 = %d\n",count);
count = temp + 1;
pthread_mutex_unlock(&mutex);
++i;
}
return NULL;
}
void* doSth2(void *arg)
{
int i = 0;
while (i < 50000)
{
pthread_mutex_lock(&mutex);
int temp = count;
printf("count 2 = %d\n",count);
count = temp + 1;
pthread_mutex_unlock(&mutex);
++i;
}
return NULL;
}
int main(int argc, const char *argv[])
{
pthread_t tid[2];
pthread_mutex_init(&mutex,NULL); //此时 有了一把锁
int ret = pthread_create(&tid[0],NULL,doSth1,NULL);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
ret = pthread_create(&tid[1],NULL,doSth2,NULL);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
return -1;
}
pthread_join(tid[0],NULL);
pthread_join(tid[1],NULL);
pthread_mutex_destroy(&mutex);
return 0;
}练习：
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<string.h>
#include <stdlib.h>
#include<errno.h>
#include<pthread.h>
#define N 2
int cnt;
pthread_mutex_t mutex;
void *do_write1(void *arg)
{
int i = 0;
while(i < 100)
{
pthread_mutex_lock(&mutex);
fprintf(arg,"thread1 cnt = %d\n",cnt);
fflush(arg);
++i,++cnt;
pthread_mutex_unlock(&mutex);
}
}
void *do_write2(void *arg)
{
int i = 0;
while(i < 100)
{
pthread_mutex_lock(&mutex);
fprintf(arg,"thread2 cnt = %d\n",cnt);
fflush(arg);
++i,++cnt;
pthread_mutex_unlock(&mutex);
}
}
void cleanup(void *arg)
{
pthread_attr_destroy(arg);
printf("cleanup\n");
}
typedef void *(*threadF_t)(void *);
int main(int argc, const char *argv[])
{
if(argc != 2)
{
printf("Usage : %s <filename> ",argv[0]);
return -1;
}
FILE *fp = fopen(argv[1],"w+");
if(fp == NULL)
{
perror("open fail");
return -1;
}
int i = 0;
pthread_t tid[N];
threadF_t pFunc[] = {do_write1,do_write2,NULL};
pthread_mutex_init(&mutex,NULL);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
for(i;i < N;++i)
{
int ret = pthread_create(&tid[i],&attr,pFunc[i], fp);
if (ret != 0)
{
errno = ret;
perror("pthread_create fail");
exit(EXIT_FAILURE); //这个宏中的值是-1
}
}
pthread_mutex_destroy(&mutex);
pthread_cleanup_push(cleanup,&attr);
pthread_cleanup_pop(1);
pthread_exit(NULL);
fclose(fp);
return 0;
}Tips：
一、断错误处理：
1、gcc <filename> -g
2、gdb ./执行文件
3、在gdb下运行 输入r即可。
二、获得当前的tid
pthread_self();
