Linux高级编程_28_进程

于 2024-10-04 16:12:52 发布
阅读量645 收藏 12
点赞数 18
分类专栏： Linux高级编程 文章标签： linux C Process
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51253120/article/details/142703894
版权

文章目录

进程

概述： 一个正在进行的程序

并行与并发

  • 并行： 执行的程序在不同CPU上同时执行
  • 并发： 一个CPU 多个进程交替执行，因为交替速度很快，所以从宏观上看是同时执行的，但本质就是交替执行。

单道与多道程序

单道程序设计：所有进程一个一个排队执行。若A阻塞，B只能等待，即使CPU处于空闲状态，已弃用

多道程序设计: 在计算机内存中同时存放几道相互独立的 程序 ， 它们在管理程序控制之下，相互穿插的运行（并行和并发)

进程控制块(PCB)了解

进程运行时,内核为进程每个进程分配一个PCB（进程控制块）,维护进程相关的信息,Linux内核的进程控制块是
task_struct结构体

task_struct结构体

在 /usr/src/linux-headers-xxx/include/linux/sched.h 文件中可以查看task_struct结构体定义

其内部成员有很多，我们掌握以下部分即可：
进程 id: c语言使用pid_t的类型表示, 其实就是一个非负整数
进程的状态：有就绪、运行、挂起、停止等状态。

PCB存储位置

在内核中

在这里插入图片描述

进程号：

当前进程的 ID 就是进程号 由系统分配

每一个进程都由一个进程号来标识 其类型为 pid_t 进程号的范围： 0~32767

进程号总是唯一的 但是可以重用 当一个进程结束后，其进程号就可以再次使用了

进程号 为 0 和 1 的进程由内核创建

进程号为 0 的进程通常是 **调度进程，**常被称为交换进程（swapper)。进程号为1 的进程 通常是 init 进程。

除调度进程(0号进程)外，在 linux 下面所有的进程都由进程 init [1]进程直接或者间接创建。

进程号：（PID）

​ 标识进程的一个非负整型数

获取当前进程的进程号 ：

​ pid_t getpid( );

​ pid_t 是进程号 是 int 型

进程组号：（PGID）

​ 多个进程在同一组中，该组就是进程组

​ 该组中第一个进程就是组长进程，该组长的进程号就是该进程组的 id

​ 由 进程A 开启的子进程 默认为进程A为同组进程 ，此时A 就是组织进程

获取指定进程的进程组号 ：

​ pid_t getpgid ( int pid );

父进程号：（PPID）

​ 由进程A 开启 B 此时进程A 就是B 的父进程

​ 进程B 就是 A 的子进程

获取父进程的进程号 ：

​ pid_t getppid();

当进程A 优先 于 进程B 先销毁 此时B就是孤儿进程 （父先挂子存在）此时由1进程充当 父进程

示例：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
using namespace std;
int main(int argc, char const *argv[])
{
 //获取当前进程id
 int  pid = getpid();
 cout<<"当前进程号为"<<pid<<endl;
 //获取同组进程id
 int pgid = getpgid(pid);
 cout<<"当前进程组为"<<pgid<<endl;

 //获取父进程id
 int  ppid = getppid();
 cout<<"当前进程父进程id为"<<ppid<<endl;


 //创建子进程
 int xxz_id = fork(); 
 if(xxz_id == 0)
 {
     cout<<"子进程号"<<getpid()<<endl;
     cout<<"子进程的父进程号"<<getppid()<<endl;
     cout<<"当前进程组为"<<getpgid(getpid())<<endl;
     sleep(5);
     exit(0);
 }
 else if (xxz_id >0 )
 {
     wait(NULL);
 }
 return 0;
}

在这里插入图片描述

fork函数

作用： 创建进程

语法：

pid_t fork();
返回值：
 如果在子进程中   返回值就是0，
 如果在父进程中   就是创建的子进程id，
 -1创建失败

fork失败的两个主要原因是：

  • 1）当前的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN。
  • 2）系统内存不足，这时errno的值被设置为ENoM

注意：
1 子进程会从fork函数后开始执行

​ 2 子进程共享父进程所有内容，不包括进程号，父进程号等

	使用fork函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间。
	地址空间：包括进程上下文、进程堆栈、打开的文件描述符、信号控制设定、进程优先级、进程组号等。
	子进程所独有的只有它的进程号，计时器等。

因此，使用fork 函数的代价是很大的。共享相当于 复制了一份

​ 3 谁创建谁回收

示例1

子进程会从fork函数后开始执行

#include <iostream>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
using namespace std;
int main(int argc, char const *argv[])
{
     // 只有父进程执行
     printf("这是一行废话,当前进程 %d\n", getpid());
     // 子进程会从fork函数后开始执行
     int pid = fork();                            // 创建子进程
     printf("hello 进程 当前进程%d\n", getpid()); // 执行两次
     return 0;
}

在这里插入图片描述

示例2 ：

子进程共享父进程所有内容，不包括进程号，父进程号等

#include <iostream>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
using namespace std;
int main(int argc, char const *argv[])
{
     printf("这是一行废话,当前进程");
     // 子进程共享父进程所有内容，不包括进程号，父进程号等 包括缓冲区
     int pid = fork(); // 创建子进程
     printf("hello 进程 当前进程%d\n", getpid());
     return 0;
}

在这里插入图片描述

示例3：

#include <iostream>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
int main(int argc, char const *argv[])
{
     char *str = "这是一行废话";
     // 此时输出的内容直接在屏幕上不在缓冲区
     write(1, str, strlen(str));
     int pid = fork();
     printf("hello 进程 当前进程%d\n", getpid());
     return 0;
}

在这里插入图片描述

引入多进程创建

在这里插入图片描述

也就是对下面这句话的理解

使用fork函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间。
地址空间：包括进程上下文、进程堆栈、打开的文件描述符、信号控制设定、进程优先级、进程组号等。
子进程所独有的只有它的进程号，计时器等。

在这里插入图片描述

那这样要是创建多进程呢

多进程创建

解决方案：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
// 多线程创建 但是没人 回收
int main(int argc, char const *argv[])
{
    for (int i = 0; i < 4; i++)
    {
        //创建子线程
        int pid = fork();
        // 父进程中 pid > 0
        // 子进程中 pid = 0
        if (pid == 0)  
        {
            // 子进程代码
            printf("子进程 %d 的进程号是 %d\n", i, getpid());
            break;
        }
    }
    return 0;
}

此处只是多进程创建 但是 注意 进程 谁创建就要由谁回收 所以 多进程创建就牵扯多进程回收

进程状态

三状态：

​ 就绪态 执行态 等待态

在这里插入图片描述

五状态：

​ 新建态、终止态、运行态、 就绪态、阻塞态

在这里插入图片描述

注意：

​ 阻塞态在其他语言中进行细分又可以分为阻塞态与休眠态

​ 休眠态又可以分为有限期休眠与无限期休眠

​ 休眠状态下不会抢夺CPU 执行权

进程资源的回收

概述:

因为子进程创建的时候 共享（也就是拷贝）父进程

在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，
这些信息主要主要指进程控制块PCB的信息（包括进程号、退出状态、运行时间等）；

回收原则：谁创建谁回收(父进程 回收 子进程资源);

1 wait函数:

作用：回收进程资源

头文件

  • #include <sys/types.h>
  • #include <sys/wait.h>

语法：

pid_t wait(int *status);      //阻塞

功能：

#include <sys/types.h>
#include <wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char const *argv[])
{
     // 创建子进程
     int pid = fork();
     if (pid == 0) // 子进程中
     {
           for (int i = 0; i < 5; i++)
           {
               // 休眠一秒
               sleep(1);
               printf("子进程%d 已经休眠了%d秒\n", getpid(), i + 1);
           }
     }
     else if (pid > 0) // 父进程
     {
           // 依据回收原则
           // wait函数回收子进程
           // wait函数用于回收子进程，但是会阻塞当前进程，直到有需要回收子进程为止
           // 如果当前进程中所有的子进程都以被回收，该函数不会阻塞当前进程，会返回-1
           int s = 0;
           int id = wait(&s); // 函数传入的参数是指针 所以是 &
           printf("当前进程%d回收了进程%d\n", getpid(), id);
           printf("状态码是:%d\n", s);
           // 状态码使用的少
     }
     return 0;
}

在这里插入图片描述

2 exit 与 _exit()

区别：

  • 1,exit函数属于库函数
  • 2,_exit函数属于系统调用 【效率高】
exit函数
所需头文件
	#include <stdlib.h>
函数：
	void exit(int status)；
参数：
	退出状态，0，正常退出，非0异常退出
_exit函数【*】
所需头文件
	#include <unistd.h>
函数：
	void _exit(int status);
参数：
	退出状态，0，正常退出，非0异常退出

> 注意 退出状态码取值区间   0~255

示例：

在子进程 计算 10 内数之和，在主进程打印结果

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

//   > 注意 退出状态码取值区间   0~255
// 在子进程 计算 10 内数之和，在主进程打印结果

// 退出当前进程   库函数exit()   系统调用_exit()
int main(int argc, char const *argv[])
{ 
    int pid = fork(); // 创建子线程
    if (pid == 0)
    {
        int sum = (0 + 10) * 11 / 2;
        sleep(2);
        _exit(sum); // 将sum作为其状态码
    }
    else if (pid > 0) // 父进程
    { 
        int s = 0;
        int pid = wait(&s);    //使用了  wait   回收  进程  但是会阻塞当前进程  一直到 子进程  被回收
        printf("s = %d\n", s);
        printf("退出时状态 %d\n", WIFEXITED(s));
        printf("退出时状态 码 %d\n", WEXITSTATUS(s));
    }
    return 0;
}

在这里插入图片描述

3 WIFEXITED(status)与WEXITSTATUS(status)

作用： 从状态码中获取信息

  • 获取进程退出时状态 WIFEXITED(status)
  • 获取进程退出时的状态码 WEXITSTATUS(status)
WIFEXITED:判断进程是否正常退出
	取出子进程的退出信息 WIFEXITED(status）如果子进程是正常终止的，取出的字段值非零。
WEXITSTATUS（status）：返回子进程的退出状态值
	退出状态值保存在status变量的8~16 位。

语法：

WIFEXITED(status)

WEXITSTATUS(status)

4 waitpid函数 【*】

 > wait函数用于回收子进程，但是会阻塞当前进程，直到有需要回收子进程为止


 >  waitpid 优势 就是不阻塞主进程 多进程创建的回收

作用： 回收进程

语法：

头文件
	#include <sys/types.h>
	#include <sys/wait.h>
语法
	pid_t waitpid(pid_t pid, int *status, int options);
功能:
	等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。
参数：
	1 pid : 【基本只用到 -1】
			参数 pid 的值有以下几种类型：
		pid > 0 等待进程 ID 等于 pid 的子进程。
		pid = 0 等待同一个进程组中的任何子进程,如果子进程已经加入了别的进程组,waitpid 不会等待它。
		pid = -1 等待任一子进程，此时 waitpid 和 wait 作用一样。
		pid < -1 等待指定进程组中的任何子进程，这个进程组的 ID 等于 pid的绝对值。
	2 status : 【基本是NULL】
			进程退出时的状态信息。和 wait() 用法一样。
	3 options : 【基本只用 wnohang】
			options 提供了一些额外的选项来控制 waitpid()。
					0：同 wait()，阻塞父进程，等待子进程退出。
					WNOHANG：没有任何已经结束的子进程，则立即返回。（非阻塞）
					WUNTRACED：如果子进程暂停了则此函数马上返回，并且不予以理会子进程的结束状态。（由于涉及到一些跟踪调试方面的知识，加之极少用到）
返回值：
		1)当正常返回的时候，waitpid() 返回收集到的已经回收子进程的进程号；
		2)如果设置了选项 WNOHANG，而调用中 waitpid() 还有子进程在运行,且没有子进程退出，返回0, 父进程的所有子进程都已经退出了返回-1； 返回>0表示等到一个子进程退出；（重要）
		3)如果调用中出错，则返回-1，这时 errno 会被设置成相应的值以指示错误所在，
	如:当pid所对应的子进程不存在,或此进程存在,但不是调用进程的子进程,waitpid()就会出错返回,这时errno被设置为ECHILD

多进程回收

弥补上面只创建了多进程而没有进行回收的问题

【模板】

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

// 多线程创建 并回收 

int main(int argc, char const *argv[])
{
    // 多进程的创建 i就是 几个线程的创建 else if 就增加到i
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        int pid = fork();
        if (pid == 0)
        {
            printf("进程%d被创建了\n",getpid());
            break;
        }
    }
    if (i == 0)
    {
        printf("i = %d,当前进程号：%d\n", i, getpid());
    }
    else if (i == 1)
    {
        printf("i = %d,当前进程号：%d\n", i, getpid());
    }
    else if (i == 2)
    {
        printf("i = %d,当前进程号：%d\n", i, getpid());
    }
    else  if (i == 3) // 能走到这 就只能是父进程了
    {
        printf("i = %d,父进程\n",i);
        // 注意使用非阻塞的 waitpid() 要用死循环
        //  waitpid(-1,NULL,WNOHANG) 此函数回收进程时  一参基本就是-1  二参只有不要状态码就是null  基本就用的时三参
        while (1)
        {
            int pid = waitpid(-1, NULL, WNOHANG);
            if (pid == -1)
            {
                printf("所有子进程都已经回收\n");
                break;
            }
            // else if (pid > 0)
            // {
            //     printf("子进程%d被回收\n", pid);
            // }
        }
    }
    return 0;
}

在这里插入图片描述

5 atexit函数

作用：进程在退出前可以用 atexit 函数注册退出处理函数

> 注意：
		1，一个进程可以登记多至 32 个函数，这些函数将由exit自动调用。我们称这些函数为终止处理程序，用atexit函数来登记这些函数。
		2, 以登记这些函数的相反顺序调用它们。同一函数如若登记多次，则也被调用多次
		3, 执行注册的函数  还是子进程

语法：

int atexit (void (*_func) (void))

示例：

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <wait.h>
#include <stdlib.h>
void fun01()
{
    printf("函数1\n,当前进程是%d\n",getpid());
}
void fun02()
{
    printf("函数2\n");
}
void fun03()
{
    printf("函数3\n");
}

int main(int argc, char const *argv[])
{
    int pid = fork();
    if (pid == 0)
    {
        // 注册退出处理函数
        atexit(fun01);
        atexit(fun02);
        atexit(fun03);
        atexit(fun01);
        printf("当前 子 进程%d end\n", getpid());
    }
    else if (pid > 0)
    {
        wait(NULL); // 状态码不要
        printf("当前 父 进程%d end\n", getpid());
    }

    return 0;
}

在这里插入图片描述

特殊进程

僵尸进程

> 子进程退出，父进程没有回收子进程资源，子进程为僵尸进程   （有危害)
> 子进程的PID被占用，系统的PID是有数量限制。

孤儿进程

>  父进程先结束，子进程为孤儿进程．                     （无害的)  
>  孤儿进程被1号进程接管（当孤儿进程结束时，1号进程负责回收其资源

守护进程

> 概念：又名精灵进程，是脱离终端的孤儿进程。

进程补充：

1 终端

终端：是与计算机系统相连的一种输入输出设备

> 在UNIx系统中,用户通过终端登录系统后得到一个shell进程,这个终端成为shell进程的控制终端（ControllingTerminal）,进程中，控制终端是保存在PCB中的信息，而fork会复制PCB中的信息，因此由Shel1进程启动的其它进程的控制终端也是这个终端。

在这里插入图片描述

> 	一个终端同时只能被一个进程池操作
	当shell进程启动a.out后,将终端的控制权交给了a.out,而shell进程失
	去了终端控制权,此时在终端中输入内容,是被a.out接收.
	当a.out进程结束,会将终端控制权交还给shell进程
	如果父进程先与子进程结束，子进程此时不能输入，只能输出

函数：

作用:
	获取当前进程所属终端名称
			#include <unistd.h>
			char *ttyname(int fd);
	功能：由文件描述符查出对应的文件名
		参数：fd:文件描述符
		返回值：
				成功：终端名
				失败：NULL

示例：证明是同一终端【其实就是底部黑框】

#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<sys/wait.h>
#include<stdlib.h>//exit
int main(int argc, char *argv[])
{
    pid_t pid = fork();
    if(pid == 0)//子进程
    {
        sleep(2);
        int num = 0;
        scanf("%d", &num);
        printf("子进程%u中的num=%d,所属终端名:%s\n", getpid(), num, ttyname(0));
    }
    else if(pid > 0)//父进程
    {
        int num = 0;
        scanf("%d", &num);
        printf("父进程%u中的num=%d,所属终端名:%s\n", getpid(), num, ttyname(0));
    }

    return 0;
}

发现 终端名都是一样的 都是 dev/pts/25

在这里插入图片描述

2 进程组

概念：

>	代表一个或多个进程的集合。
	每个进程都有对应的进程组。
	进程组ID为当前进程中第一进程的ID。
	如果一个进程的ID和组ID相同那么这个进程就是组长进程。
	当父进程，创建子进程的时候，默认子进程与父进程属于同一进程组。
	shel1进程启动的进程独立为一个进程组
	如果进程中只是组长进程结束，当前进程组不会解散.只有进程组的所有进程离开(终止或转移），该进程组才会解散。
	一个进程可以为自己或子进程设置进程组ID。
		注意:组长进程不能设置进程组id

			如果进程 ID==进程组 ID==会话ID，那么该进程为会话首进程（会长）。

示例：

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    int xxz_pid = fork(); // 创建子进程
    if (xxz_pid == 0)
    {    
        printf("当前子进程id:%d\t所属进程组id:%d\n",getpid(),getpgrp());//getpgrp（）:获取当前进程所在的进程组id
    }
    else if ( xxz_pid > 0)
    {
       printf("当前父进程id:%d\t所属进程组id:%d\n",getpid(),getpgrp());
    }
    return 0;
}

在这里插入图片描述

设置当前进程或子进程所在的进程组

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    int xxz_pid = fork(); // 创建子进程
    if (xxz_pid == 0)
    {   
        //设置当前进程或子进程所在的进程组
        setpgid(getpid(),getpid()); 
        printf("当前子进程id:%d\t所属进程组id:%d\n",getpid(),getpgrp());  //getpgrp（）:获取当前进程所在的进程组id
    }
    else if ( xxz_pid > 0)
    {
       printf("当前父进程id:%d\t所属进程组id:%d\n",getpid(),getpgrp());
    }
    return 0;
}

a

3 会话

概念：

>	
	会话是一个或多个进程组的集合。
	一个会话可以有一个控制终端。这通常是终端设备或伪终端设备;建立与控制终端连接的会话首进程被称为控制进程;
	一个会话中的几个进程组可被分为一个前台进程组以及一个或多个后台进程组;
	如果一个会话有一个控制终端，则它有一个前台进程组，其它进程组为后台进程组;
	如果终端接口检测到断开连接，则将挂断信号发送至控制进程（会话首进程）

函数getsid

> 作用:获取会话id
	所需头文件
			#include <unistd.h>
	函数
			pid_t getsid(pid_t pid);
	参数：
			pid：进程号，pid 为 0 表示查看当前进程 session ID(会话id)
	返回值：
			成功：返回调用进程的会话 ID
			失败：-1
组长进程不能成为新会话首进程，新会话首进程必定会成为组长进程。

函数setsid

>
	作用:创建会话
				所需头文件
						#include <unistd.h>
				函数:
					pid_t setsid(void);
				功能：
					创建一个会话，并以自己的 ID 设置进程组 ID，同时也是新会话的 ID。调用了setsid 函数的进程，既是新的会长，也是新的组长。
				参数：
						无
				返回值：
						成功：返回调用进程的会话 ID
						失败：-1
注意实现:
1,组长进程不能设置为会话
2,需有root权限(ubuntu 不需要)
3,新会话丢弃原有的控制终端，该会话没有控制终端

示例1：

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <stdlib.h>
//     会话
int main(int argc, char const *argv[])
{
     int xxz_pid = fork();
     if (xxz_pid == 0)
     {
           setpgid(getpid(), getpid());
           printf("当前子进程id:%d\t所属进程组id:%d\t所属会话id:%d\n", getpid(), getpgrp(), getsid(getpid()));
     }
     else if (xxz_pid > 0)
     {
           printf("当前父进程id:%d\t所属进程组id:%d\t所属会话id:%d\n", getpid(), getpgrp(), getsid(getpid()));
     }
     return 0;
}

在这里插入图片描述

示例2： 创建新会话

注意 组长id 不能设置为会话

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
#include <wait.h>
#include <stdlib.h>
//     创建新会话  
int main(int argc, char const *argv[])
{
 int xxz_pid = fork();
 if (xxz_pid == 0)
 {
     // 设置当前进程或子进程所在的进程组
     // setpgid(getpid(), getpid());
     // 设置当前进程为一个新的会话
     // 组长进程不能设为新的会话
     setsid();
     printf("当前子进程id:%d\t所属进程组id:%d\t所属会话id:%d\n", getpid(), getpgrp(), getsid(getpid()));
 }
 else if (xxz_pid > 0)
 {
     printf("当前父进程id:%d\t所属进程组id:%d\t所属会话id:%d\n", getpid(), getpgrp(), getsid(getpid()));
 }
 return 0;
}

在这里插入图片描述

4 守护进程

  • 1 忽略SIGHUP(信号)防止被终端误杀
  • 2 创建子进程，父进程退出(必须) 所有工作在子进程中进行形式上脱离了控制终端
  • 3 在子进程中创建新会话(必须) setsid()函数使子进程完全独立出来，脱离控制
  • 4 改变当前目录为根目录(不是必须) chdir()函数 防止占用可卸载的文件系统 也可以换成其它路径
  • 5 重设文件权限掩码(不是必须)umask()函数 防止继承的文件创建屏蔽字拒绝某些权限 增加守护进程灵活性
  • 6 关闭文件描述符(不是必须) 继承的打开文件不会用到，浪费系统资源，无法卸载
  • 7 开始执行守护进程核心工作(必须) 守护进程退出处理程序模型

vfork

函数：

pid_t vfork(void);

作用：

vfork 函数和fork 函数一样都是在已有的进程中创建一个新的进程，但它们创建的子进程是有区别的

vfork保证子进程先运行，在它调用exec或exit之后，父进程才可能被调度运行。

vfork 和fork一样都创建一个子进程，但它并不将父进程的地址空间完全复制到子进程中，因为子进程会立即调用

exec(或exit)，于是也就不访问该地址空间。

exec函数簇 【*】

建议：

  • 调用系统的 使用 execlp ()
  • 调用别人的 用 execl ()

语法:

int execl(const char *path, const char *arg, .../* (char  *) NULL */);
int execlp(const char *file, const char *arg, .../* (char  *) NULL */);
int execle(const char *path, const char *arg, .../*, (char *) NULL, char * const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],char *const envp[]);

作用：

如果想要通过运行的进程，启动另一个程序，需要用到exec函数

exec 后字母的含义

>	l：表示exe函数族的参数是通过列表（list），传递。
	v:表示exe函数族的参数是通过指针数组（vector），传递。
	p:p表示通过环境变量查找命令（程序）
	e:可以使用系统环境变量。
注意：
	exec 函数族的 最后一个 参数为NULL，

示例：

#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    printf("执行exec前\n");
    // 此时我们发现,该函数后的代码没有被执行
    // 因为exec启动了别人的程序,顾执行的是启动的程序中的代码
    // 将不在执行当前进程中的代码
    // execl("/usr/games/sl","./sl",NULL);
    // execl("/bin/ls","./ls","-l","-a",NULL);
    //  execl("/bin/ls","./ls","-la",NULL);
    // p:在环境变量path中寻找
    //  execlp("ls","./ls","-la",NULL);
    // 此时t.out不在环境变量中,顾找不到
    //  execlp("t.out","./t.out",NULL);
    //  execl("./t.out","./t.out",NULL);
    char *tem[] = {"./ls", "-l", "-a", NULL};
    execv("/bin/ls", tem);
    printf("执行exec后\n");
    return 0;
}

exec函数族与vfork结合

优势：

  • 1,节省内存
  • 2,可以与父进程交替执行

示例1

#include <stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    for (int i = 0; i < 3; i++)
    {
        sleep(1);
        printf("test i = %d\n", i);
    }
    return 0;
}

目的：

将03_test.c编写生成可执行文件 t

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <wait.h>
int main(int argc, char const *argv[])
{
	int pid = vfork();
	if(pid == 0)
	{
		execl("./t","./t",NULL);
	}
	else if(pid > 0)
	{
		for (int i = 0; i < 3; i++)
		{
			sleep(1);
			printf("code i = %d\n",i);
		}
			wait(NULL);
	}
	return 0;
}

system

作用

system 会调用 fork 函数产生子进程，子进程调用 exec 启动要启动的其他程序

语法

	#include <stdlib.h>
		int system(const char *command);
参数：
	要执行的命令的字符串。
返回值：
	如果command 为 NULL，则system（)函数返回非 O，一般为 1。
	如果 system（)在调用/bin/sh 时失败则返回127，其它失败原因返回-1。

示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <wait.h>
int main(int argc, char const *argv[])
{
	printf("system执行前\n");
	int code = system("./my.sh");
	printf("%d\n",WIFEXITED(code));
	printf("system执行后\n");
	return 0;
}
想躺平的做题家
关注
专栏目录
linux_code.rar_linux 高级编程_linux文件编程_linux网络编程IO_linux高级
09-21
通过分析并实践压缩包中的源代码，你可以深化对Linux高级编程的理解，提高解决实际问题的能力。这是一次难得的学习机会，不仅能增进理论知识，还能提升实战技能。记得要逐行阅读代码，理解每个函数的作用，以及它们...
linux_c_func.rar_C 高级编程_linux C函数_linux 函数
09-23
本资源“linux_c_func.rar”聚焦于Linux环境下的C高级编程，旨在帮助开发者更好地理解和使用Linux C函数。 标题中的“Linux C Func”暗示了这个资料主要涵盖的内容，即与Linux操作系统相关的C语言函数库。这些函数...
linux应用编程 (高级编程)
m0_61363499的博客
07-01 1801
c -- character -- 字符设备文件 --- 鼠标 ---- ls -l /dev/input/p -- pipe -- 管道文件 --- 实现操作系统中 进程间的一些 信息交换(通信)b -- block -- 块设备文件 --- 硬盘 ---- ls -l /dev/sda。l -- link -- 软连接文件 --- 类似windows的快捷方式。s -- socket -- 套接字文件 --- 网络的时候 (进程间的通信)
Linux高级编程——进程通信（信号signal）
琛翀的风暴空间
03-04 1840
进程间通信（IPC，Inter-Process Communication） 两个或多个进程间进行数据传送，参与通信的这些进程可能位于同一台机器上，也可能位于不同的机器上。 常用 IPC 方式： 信号（Signal） 管道（Pipe） 共享内存（Shared Memory） 消息队列（Message Queue） 套接字（Socket） 信号（Signal） Linux 系统上古老经典的 IPC方式，主要用于实现异步通知，不能传输数据。 信号是一种软件中断（Software Break） void (*
linux高级编程实验
Wangguang_的博客
05-21 9017
文件管理（一） 编写代码，完成以下功能： 1.创建文件file1，写入字符串“abcdefghijklmn”； 2.创建文件file2，写入字符串“ABCDEFGHIJKLMN”; 3.读取file1中的内容，写入file2，使file2中的字符串内容为“abcdefghijklmn ABCDEFGHIJKLMN” 利用Linux进行C程序开发，首先需要了解程序要求，理清思路。 按照要求...
《Linux 高级编程》
gege_hxg的博客
11-30 2262
文章目录linux 常用工具简介：tar打包器---解压缩指令：常用命令：可执行文件查看（代码段，数据段，bss段）：堆和栈的区别：常见内存错误说明：内存分配相关理解：1.内存分配方式：2.动态分配常用函数及说明：2.1 malloc & free:2.2 realloc:2.3 calloc()：2.4 alloca (）:3 内存常用管理函数：3.1 memcpy():3.2 memmove():3.3 memset():3.4 memchr()3.5 memcmp()： 《Linux 高级程序
Linux 高级编程 - 守护进程
cdeveloper 的专栏
09-02 1496
Linux 高级编程 - 守护进程
linux 下 pthread_cond_t 详解
B.souls
11-12 4766
一览 本文目的 为何需要条件变量 三个问题 传入前锁mutex 传入后解锁mutex 返回前再次锁mutex pthread_cond_signal的两种写法 尾语 本文目的   首先说明，本文重点不在怎么用条件变量。这里我先列出apue中对于pthread_cond_wait函数的这么一段话： “ 调用者把锁住的互斥量传给函数，函数然后自动把调用线程放到等待条件的线程列表上，**对互斥量解锁。**这就关闭了条件检查和线程进入休眠状态等待条件改变这...
Linux 网络编程学习笔记——十三、多进程编程
热门推荐
BeZer0的学习笔记
03-30 1万+
进程是Linux操作系统环境的基础，它控制着系统上几乎所有的活动。
Linux高级编程——线程信号处理
程序员「阿基米东」的编程之旅
09-27 3085
Linux 多线程环境中的信号处理不同于进程的信号处理。一方面线程间信号处理函数的共享性使得信号处理更为复杂，另一方面普通异步信号又可转换为同步方式来简化处理。 　　本文首先介绍信号处理在进程中和线程间的不同，然后描述相应的线程库函数，在此基础上给出一组示例代码，以讨论线程编程中信号处理的细节和注意事项。 　　本文通过 sigwait() 调用来“等待”信号，而通过 signal()/sigac
嵌入式项目_嵌入式Linux项目分享_linux系统编程
a763450633的博客
09-25 5644
基于mplayer的嵌入式Linux 视频播放器--该项目适合正在入门嵌入式Linux系统编程的同学
linux系统编程
weever7的博客
05-07 5975
​ 第一章 系统调用 内核提供了一系列的服务、资源、支持一系列功能，应用程序通过调用系统调用 API 函数来使用内核提供的服务、资源以及各种各样的功能 1.2 库函数 库函数也就是 C 语言库函数 在 Linux 下，通常以动态（.so） 库文件的形式提供，存放在根文件系统/lib 目录下 ​库函数是属于应用层，而系统调用是内核提供给应用层的编程接口，属于系统内核的一部分 库函数运行在用户空间，调用系统调用会由用户空间（用户态）陷入到内核空间（内核态） 库函数通常是有缓存的，而系统调用是无缓存的，所以在
Linux_Net_Programing.rar_Linux 网络 编程_linux 编程_linux 编程_linux网络_
09-23
Linux网络编程是一个涵盖广泛的主题，涉及操作系统内核、网络协议栈、套接字API以及多线程编程等多个方面。在Linux环境下进行网络编程，开发者可以深入理解网络通信的底层机制，实现高性能的服务端和客户端应用。这...
linux_c_function.rar_LINUX c++ 编程_Linux C编程_linux 编程_linux c++
09-23
本资源“linux_c_function.rar”提供了一份详细的Linux环境下C编程的参考文档，涵盖了C语言和C++编程的基础以及高级知识点。下面我们将深入探讨其中的关键概念和函数。 1. **C语言基础**： - **变量与数据类型**：...
linuxwangluo.rar_linux_linux 网络编程_linux网络编程_网络编程 linux
09-20
8. **异步I/O**: 异步I/O模型如libevent、libev和Boost.Asio，能提高网络服务的性能和可扩展性，是高级网络编程的重要内容。 9. **安全编程**: 在网络编程中，应关注安全问题，如SSL/TLS加密、防止缓冲区溢出、输入...
linux 网络序
CodeHouse的博客
09-30 439
在将ip字符串转网络序存储时。根据整形二进制显示判断。
Linux 性能优化之CPU 多级缓存
山河已无恙
09-30 863
博文内容为 Linux CPU 多级缓存认知内容涉及：什么是CPU多级缓存认知，CPU 硬件缓存信息，缓存流程写入策略，映射算法认知CPU 缓存分析，使用 valgring 和 Perf 分析CPU 缓存命中情况编码方面 CPU 缓存优化，数据指令缓存，多核缓存命中率优化方式理解不足小伙伴帮忙指正 😃,生活加油哦99%的焦虑都来自于虚度时间和没有好好做事，所以唯一的解决办法就是行动起来，认真做完事情，战胜焦虑，战胜那些心里空荡荡的时刻，而不是选择逃避。
在 Kali Linux 中安装 Impacket
weixin_44023460的博客
09-30 286
在安装 Impacket 之前，你需要确保安装了 Python 和一些必要的依赖。通常，Kali 已经预装了 Python。步骤 3：克隆 Impacket 仓库。步骤 4：进入 Impacket 目录。如果你看到帮助信息，说明安装成功。步骤 5：安装 Impacket。
Linux的基本指令（2）
最新发布
shylyly_的博客
10-01 961
Linux的基本指令（2） man nano cp mv which 自制指令 alias echo cat tac > >> < more less head tail |（管道）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值