目录
1.进程相关概念
程序和进程
程序是静态的概念，gcc xx.x -o pro,磁盘中生成的pro就是程序。
进程是程序的一次运行活动，通俗的讲就是程序跑起来了，系统中就多了一个进程。
查看系统中的进程
ps指令
查看系统中所有进程
ps -aux
结果：
查看系统中的init进程
ps -aux | grep init
结果：
即把ps -aux指令所有输出的结果通过管道导向grep进行搜索，查找init关键字的文本
-aux 显示所有包含其他使用者的进程
|管道符号
grep 用于查找文件里符合条件的字符串
top指令
类似windows的任务管理器，数据也是实时动态变化的。
进程标识符 使用getpid()获取
每一个进程都有一个非负整数标识唯一的ID，即为pid。
调用getpid()获取自身进程标识符，getppid()获取获取父进程标识符
其中系统所占用的进程标识符如下：
| pid | 进程名称 | 作用 | 说明 |
|---|---|---|---|
| pid = 0 | 交换进程 | 用于进程调度 | 所有“同时”在运行的程序所占用的资源受到进程调度的影响 |
| pid = 1 | init进程 | 用于系统初始化 | 程序运行，内核加载完毕，文件系统起来的第一个进程就是init进程，读取配置文件然后再启动其他进程。（如ktv点歌机开机后看到的是点歌界面，而不是字符界面） |
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
//pid_t getpid(void);
pid_t pid;
pid=getpid();
printf("我的pid是：%d\n",pid);
return 0;
}
父进程，子进程
进程A创建了进程B，A就是父进程，B就是子进程
2.创建进程fork
pid_t fork(void);
fork函数调用成功，返回两次：返回值为0，代表当前进程是子进程，非负数为父进程，如果调用失败则返回-1
创建子进程的目的：复制父进程（此时两个或两个以上进程），父进程等待客户端服务请求，当这种请求到达时，父进程调用fork,让子进程去处理（QQ服务器 客户端 结合Socket网络编程）
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
pid_t pid;
pid = getpid();
fork();//此处开始，后面所有代码执行了两次
//fork()有两个返回值
printf("my pid is %d\n",pid);
return 0;
}
返回两次：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
pid_t pid;
pid = getpid();
fork();
printf("my pid is %d,current pro id:%d\n",pid,getpid());
return 0;
}
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
pid_t pid;
pid = getpid();
fork();
if(pid == getpid()){
printf("this is father print\n");
}else{
printf("this is child print,child pid = %d\n",getpid());
}
return 0;
}
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
pid_t pid;
printf("father: pid = %d\n",getpid());
pid = fork();
if(pid > 0){
printf("this is father print, pid = %d\n",getpid());
}else if(pid == 0){
printf("this is child print,child pid = %d\n",getpid());
}
return 0;
}
应用场景（模拟网络等待）：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
pid_t pid;
int data;
while(1){
printf("please input a data\n");
scanf("%d",&data);
if(data == 1){
pid = fork();
if(pid > 0){
}else if(pid == 0){
while(1){
printf("do net request,pid=%d\n",getpid());
sleep(3);
}
}
}else{
printf("wait, do nothing\n");
}
}
return 0;
}
进程创建发生了什么——C程序的存储空间如何分配
详细参照博文：内存四区（代码区 静态区 栈区 堆区）
fork创建进程，所有的东西都进行了拷贝，包括全局变量、局部变量、代码等，各进程内改变变量的值互不影响。
详细说明：
3.创建进程vfork(区别fork)
vfork与fork的区别：
1.（共用）vfork直接使用父进程的存储空间，不拷贝（随着内核的发展，fork目前执行的是写时拷贝—copy on write 若子进程未改变原始变量的值时不会进行拷贝）
2.（等待）vfork保证子进程先运行，当子进程调用exit退出后，父进程才执行
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
int main(){
int cnt=0;
pid_t pid;
pid_t repid;
pid=getpid();
repid=vfork();
if(repid > 0){
while(1){
printf("cnt=%d\n",cnt);
printf("this is father pid,repid=%d\n",repid);
sleep(1);
}
}
else if(repid == 0){
while(1){
printf("this is child pid,repid=%d\n",repid);
sleep(1);
cnt++;
if(cnt==2){
exit(0);
}
}
}
return 0;
}
运行结果：
4.进程退出
正常退出
1.main函数调用return
2.进程调用exit(),标准C库
3.进程调用_exit()或者_Exit(),系统调用
4.进程最后一个线程返回
5.最后一个线程调用pthread_exit
异常退出
1.调用abort
2.当进程收到某些信号时，如ctrl+c
3.最后一个线程对取消（cancellation）请求作出响应
注意：不管进程如何终止，最后都会执行内核中的同一段代码，这段代码为相应进程关闭所有打开描述符，释放它所使用的存储器等。
5.父进程等待子进程退出
父进程收集子进程退出状态(僵尸进程)
父进程等待子进程退出并收集子进程退出状态
子进程退出状态不被收集，会变成僵尸进程
僵尸进程的例子：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
pid_t pid;
int i;
int cnt=0;
pid=fork();
if(pid > 0){//父进程
while(1){
printf("这是父进程,pid=%d\n",getpid());
printf("cnt=%d\n",cnt);
sleep(2);//防止刷屏
}
}else if(pid == 0){//子进程
for(i=0;i<5;i++){//看看是不是保证子进程先运行，五次过后推出进入父进程
printf("这是子进程,pid=%d，这是第%d次\n",getpid(),i+1);
cnt++;
sleep(1);//防止刷屏
}
exit(-1);
}
return 0;
}
此时运行的结果是子进程退出了，但是退出状态没有被收集，子进程成了僵尸进程(zomb)。
等待退出函数wait()
wait(int *status):
status参数，他是一个整型数指针。
非空：子进程退出状态放在它所指向的地址
空(NULL)：不关心退出状态
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
pid_t pid;
int i;
int cnt=0;
int status;
pid=fork();
if(pid > 0){//父进程
wait(&status);
printf("子进程退出，status:%d\n",WEXITSTATUS(status));//WEXITSTATUS()是解析子进程退出码的宏，下面有详细介绍
while(1){
printf("这是父进程,pid=%d\n",getpid());
printf("cnt=%d\n",cnt);
sleep(2);//防止刷屏
}
}else if(pid == 0){//子进程
for(i=0;i<5;i++){//看看是不是保证子进程先运行，五次过后推出进入父进程
printf("这是子进程,pid=%d，这是第%d次\n",getpid(),i+1);
cnt++;
sleep(1);//防止刷屏
}
exit(3);//退出码返回给父进程中的wait进行收集
}
return 0;
}
解析出wait()对子进程退出码回收的宏
等待退出函数waitpid()
来个例子：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
pid_t pid;
int i;
int cnt=0;
int status;
pid=fork();
if(pid > 0){//父进程
waitpid(pid,&status,WNOHANG);//WNOHANG不阻塞
printf("子进程退出，status:%d\n",WEXITSTATUS(status));
while(1){
printf("这是父进程,pid=%d\n",getpid());
printf("cnt=%d\n",cnt);
sleep(2);//防止刷屏
}
}else if(pid == 0){//子进程
for(i=0;i<5;i++){//看看是不是保证子进程先运行，五次过后推出进入父进程
printf("这是子进程,pid=%d，这是第%d次\n",getpid(),i+1);
cnt++;
sleep(1);//防止刷屏
}
exit(3);
}
return 0;
}
结果如下所示，发现子进程也变为僵尸进程。
父进程先于子进程退出(孤儿进程)
父进程如果不等待子进程退出 ，在子进程之前就结束了自己的生命，此时的子进程就叫做是孤儿进程
Linux避免系统存在太多的孤儿进程，init进程收留孤儿进程，变成孤儿进程的父进程
例子：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
pid_t pid;
int i;
int status;
int cunt=0;
pid=fork();
if(pid > 0){
printf("这是父进程,pid=%d\n",getpid());
printf("cunt=%d\n",cunt);
sleep(2);
}else if(pid == 0){
for(i=0;i<5;i++){
printf("这是子进程,pid=%d,我的父进程的pid=%d\n",getpid(),getppid());
cunt++;
sleep(2);
}
exit(3);
}
return 0;
}
运行结果：
最后再来一个综合的例子：
6.exec族函数(让子进程调用其他程序)
参照博文：https://blog.youkuaiyun.com/u014530704/article/details/73848573
execl，execlp
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(){
//int execl(const char *path, const char *arg, .../* (char *) NULL */);
/* path：可执行文件的路径名字
arg：可执行程序所带的参数，第一个参数为可执行文件名字，没有带路径且arg必须以NULL结束
file：如果参数file中包含/，则就将其视为路径名，否则就按 PATH环境变量，在它所指定的各目录中搜寻可执行文件
exec族函数参数极难记忆和分辨，函数名中的字符会给我们一些帮助：
l : 使用参数列表
p：使用文件名，并从PATH环境进行寻找可执行文件
v：应先构造一个指向各参数的指针数组，然后将该数组的地址作为这些函数的参数。
e：多了envp[]数组，使用新的环境变量代替调用进程的环境变量
exec函数族的函数执行成功后不会返回，调用失败时，会设置errno并返回-1，然后从原程序的调用点接着往下执行。
*/
printf("before execl\n");
if(execl("/bin/ls","ls",NULL,NULL) == -1)//通过whereis指令找到ls命令的位置
{
printf("execl failed!\n");
perror("why");
}
printf("after execl\n");
return 0;
}
int main(){
//int execlp(const char *file, const char *arg, .../* (char *) NULL */);
printf("before execl\n");
if(execlp("ls","ls","-l",NULL) == -1)//不用找到命令的路径
{
printf("execl failed!\n");
perror("why");
}
printf("after execl\n");
return 0;
}
运行结果：
通过whereis指令查找ls、date（获取系统时间）系统指令的位置：
execv execvp
int main(){
//int execv(const char *path, char *const argv[]);
char* argv[]={"ls",NULL,NULL};
if(execv("/bin/ls",argv) == -1)
{
printf("execl failed!\n");
perror("why");
}
printf("after execl\n");
return 0;
}
int main(){
// int execvp(const char *file, char *const argv[]);
char* argv[]={"ls","-l",NULL};
if(execvp("ls",argv) == -1)
{
printf("execl failed!\n");
perror("why");
}
printf("after execl\n");
return 0;
}
exec配合fork使用
应用场景：在执行A程序的过程中让子进程去执行B程序
代码B（用来修改配置文件） 编译生成程序名为change
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
int fd;
int n_write;
int n_read;
pid_t pid;
char *readBuf;
fd=open("test15.txt",O_RDWR);
int size=lseek(fd,0,SEEK_END);//计算文件的大小
lseek(fd,0,SEEK_SET);//光标重新到开头
readBuf=(char *)malloc(sizeof(char)*size+8 );//+8防止溢出
n_read=read(fd,readBuf,size);
char *p=strstr(readBuf,"length=");
if(p == NULL ){
printf("没有找到\n");
exit(-1);
}
p=p+strlen("length=");//指针往后移动大哦想要改的地方
*p='9';//将里面的6改称9
lseek(fd,0,SEEK_SET);
n_write=write(fd,readBuf,strlen(readBuf));
close(fd);
exit(0);
}
代码A
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
int fd;
int n_write;
int n_read;
pid_t pid;
int data;
char *readBuf;
while(1){
printf("请输入一个数\n");
scanf("%d",&data);
if(data == 1){
printf("成功进入\n");
pid=fork();
if(pid > 0){//父进程
wait(NULL);//防止子进程变成僵尸进程
}
if(pid == 0){//子进程
execl("./change","change",NULL,NULL);//获取系统时间也能实现
}
}else{
printf("等待输入正确的指令\n");
}
}
return 0;
}
初始的test15.txt
运行程序A后
system函数
本质上是对execl函数的二次封装，可查看其源码。实际上比execl更好用
和execl区别：system执行完该函数后，还会继续执行后面的函数 ，而exec则不会。
#include <stdlib.h>
int system(const char *command);
system()函数返回值如下：
成功，则返回进程的状态值
当sh不执行时，返回127；//shell脚本
失败返回 -1
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
int main(){
pid_t pid;
pid_t repid;
int data;
while(1){
printf("please input a number:");
scanf("%d",&data);
if(data==1){
repid=fork();//创建进程
if(repid > 0){
wait(NULL);
}
if(repid == 0){
//execl("./changeNumToFile.out","changeNumToFile.c","changeNum.c",NULL);
system("./changeNumToFile.out");//执行完该函数后，还会执行后面的函数 exec就不会回来继续执行后面代码了，除非execl出错返回-1
exit(0);
}
}
else{
printf("waiting!\n");
}
}
return 0;
popen函数(对比system的好处,可以获取运行的输出结果)
#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);
#include <stdio.h>
#include <stdlib.h>
// FILE *popen(const char *command, const char *type);
// FILE *fopen(const char *path, const char *mode);
// size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
int main(){
// system("ls");
FILE* fp;
char ret[1024];
fp=popen("ls -l","r");
int n_read=fread(ret,1,1024,fp);
if(n_read != -1){
printf("read sucess!\n");
printf("return n_read=%d,read data=%s\n",nread,ret);
}
else{
printf("no read datas\n");
}
return 0;
}
扫一扫
816
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
