【进程】理解进程、相关代码演示

已于 2023-09-10 20:29:05 修改
阅读量525 收藏 5
点赞数 3
文章标签： linux c语言 c++ 进程 进程创建
于 2023-07-03 16:55:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crr411422/article/details/131501849
版权

目录

0. 进程概述

1. 创建进程

1.1 进程的创建：fork函数

1.2 进程的等待：wait()、waitpid()

1.3 特殊进程：僵尸进程、孤儿进程、守护进程

1.4 进程的终止：exit和_exit函数

1.5 进程退出清理：atexit函数

1.6 进程的创建 ：vfork函数

2. 进程的替换：exec函数族

3. system函数：

总结：

0. 进程概述

进程的定义

程序和进程的区别：

  •         程序：是静态的，存放在磁盘上的可执行文件。
  •         进程：是动态的，是运行在内存中的程序的执行实例。
  •         程序是一些指令的有序集合，而进程是程序执行的过程，进程是程序的一次执行过程。
  •         进程的状态是变化的，其包括进程的创建、调度和消亡。
  •         程序只要运行，此时就是进程，程序没运行一次，就会创建一个进程。

在Linux系统中，进程是管理事务的基本单元。

进程拥有自己独立的处理环境和系统资源（处理器、存储器、I/O设备、数据、程序）。

进程的状态及转换：

进程整个生命周期可以简单的划分为三种状态：

就绪态：

        进程已经具备执行的一切条件，正在等待分配CPU的处理时间。

执行态：

        该进程正在占用CPU运行。

等待态：

        进程因不具备某些执行条件而暂时无法继续执行的状态。

进程的调度机制：

        时间片轮转，上下文切换。

        多进程不是说一个进程执行完再执行另一个进程，而是交替执行的，一个进程执行一段时间，然后下一个进程再执行一段时间，依次类推，所有进程执行完之后再回到第一个进程继续执行，依次类推。

进程三个状态的转换关系：

 进程控制块：

        进程控制块就是用于保存一个进程信息的结构体，又称之为PCB。

        OS是根据PCB来对并发执行的进程进行控制和管理的。系统在创建一个进程的时候会开辟一段内存空间存放与此进程相关的PCB数据结构。

        PCB是操作系统中最重要的记录型数据结构。PCB中记录了用于描述进程进展情况及控制进程运行所需的全部信息。

        PCB是进程存在的唯一标志，在Linux中PCB存放在task_struct结构体中。

        /usr/src/linux-heads....generic/include/linux/sched.h

PCB结构体中的部分数据：

调度数据：

        进程的状态、标志、优先级、调度策略等。

时间数据：

        创建该进程的时间、在用户态的运行时间、在内核态的运行时间等。

文件系统数据：

        umask掩码、文件描述符表等。

内存数据、进程上下文、进程标识（进程号）

。。。

进程控制：

进程号：

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

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

在ubuntu中查看当前系统中所有的开启的进程：

ps ajx

PPID：当前进程的父进程的进程号。

PID：当前进程的进程号。

PGID：当前进程所在的组的进程组ID。

COMMAND：当前进程的名字

特殊的进程号：

  •         在Linux系统中进程号由0开始。
  •         进程号为0及1的进程由内核创建。
  •         进程号为0的进程通常是调度进程，常被称为交换进程（swapper）。
  •         进程号为1的进程通常是init进程，init进程是所有进程的祖先。
  •         除调度进程外，在Linux下面所有的进程都由init进程直接或间接创建。

进程号（PID）

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

父进程号（PPID）

        任何进程（除Init进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID）。

进程组号（PGID）

        进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID）。

Linux操作系统中提供了三个获得进程号的函数getpid()、getpgid()、getppid()。

#include<sys/types.h>

#include<unistd.h>

pid_t getpid(void);

功能：获取当前进程的进程号。

pid_t getppid(void);

功能：获取当前进程的父进程的进程号。

pid_t getpgid(pid_t pid);

功能：获取当前进程所在进程组的进程号。

代码示例：

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

int main()
{
    printf("pid = %d\n", getpid());
    printf("ppid = %d\n", getppid());
    printf("pgid = %d\n", getpgid(getpid()));
    while (1);
    return 0;
}

执行截图：

1. 创建进程

1.1 进程的创建：fork函数

fork函数：

#include<unistd.h>

pid_t fork(void);

功能：在已有的进程基础上创建一个子进程。

参数：

        无

返回值：

        成功：

                >0：子进程的进程号，标识父进程的代码区。

              ==0：子进程的代码区。

        失败：

                -1：返回给父进程，子进程不会创建。

        使用fork函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间。

地址空间：

        包括进程上下文、进程堆栈、打开的文件描述符、信号控制设定、进程优先级、进程组号等。子进程所独有的只有它的进程号，计时器等。因此，使用fork函数的代价是很大的。 

fork函数执行完毕后父子进程的空间示意图：

创建子进程

不区分父子进程（不推荐）

代码示例：

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

int main()
{
    //通过fork函数创建一个子进程
    //注意：只要执行了一次fork，就会在原有的进程基础上创建一个新的子进程
    //而且如果fork之后不区分父子进程的代码区，则后面的所有代码都会执行
    fork();
    printf("hadj{\n");
    while (1);
    return 0;
}

执行截图：

区分父子进程（推荐）

代码示例：

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


int main()
{
    //父子进程是来回交替执行的，谁先谁后不一定。
    pid_t pid;
    pid = fork();
    if (pid < 0)    //创建子进程失败
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)   //父进程代码区
    {
        while (1)
        {
            printf("in parent process\n");
            sleep(1);
        }
    }
    else   //子进程代码区（pid == 0)
    {
        while (1)
        {
            printf("in son process\n");
            sleep(1);
        }
    }
    return 0;
}

执行截图：

父进程拥有独立的地址空间、

代码示例：

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

int a = 555;

int main()
{
    pid_t pid;
    pid = fork();
    static int  b = 777;
    int c = 888;
    //子进程会复制父进程fork之前的所有内容
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in partent process\n");
        a++;
        b++;
        c++;
        printf("a = %d, b = %d, c = %d\n", a, b, c);
    }
    else
    {
        sleep(1);
        printf("in son process\n");
        printf("a = %d, b = %d, c = %d\n", a, b, c);
    }
    while (1);

    return 0;
}

执行截图：

 代码示例：

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


int main()
{

    int fd;
    if ((fd = open("file.txt", O_RDONLY)) == -1)
    {
        perror("fail to open");
        exit(1);
    }
    //子进程会继承父进程的一些共有的区域，例如磁盘空间，内核空间。
    //文件描述符的偏移量保存在内核空间中，所以父进程改变偏移量，子进程获取的偏移量是改变之后的。
    pid_t pid;
    pid = fork();

    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in parent process\n");
        char  buf[32] = "";
        if (read(fd, buf, 30) == -1)
        {
            perror("fail to read");
            exit(1);
        }
        printf("buf = [%s]\n", buf);
    }
    else
    {
        sleep(1);
        printf("in son process\n");

        char buf[32] = "";
        if (read(fd, buf, 30) == -1)
        {
            perror("fail to read");
            exit(1);
        }
        printf("buf = [%s]\n", buf);

    }
    while (1);
    return 0;
}

执行截图：

子进程继承父进程的空间

进程的挂起：

进程在一定的时间内没有任何动作，称为进程的挂起。

#include<unistd.h>

unsigned int sleep(unsigned in sec);

功能：

        进程挂起指定的秒数，知道指定的时间用完或受到信号才解除挂起。

返回值：

        若进程挂起到sec指定的时间则返回0，中断则返回剩余秒数。

注意：

        进程挂起指定的秒数后程序并不会立即执行，系统只是将此进程切换到就绪态。

代码示例：

#include<unistd.h>
#include<stdio.h>

int main()
{
        while(1)
        {
                printf("hello world\n");
                sleep(2);
        }
        return 0;
}

执行截图：

 

1.2 进程的等待：wait()、waitpid()

父子进程有时需要简单的进程间同步，如父进程等待子进程的结束。

Linux下提供了两个等待函数wait()、waitpid()。

wait函数

#include<sys/types.h>

#include<sys/wait.h>

pid_t wait(int *status);

功能：

        等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。

        调用wait函数的进程会挂起，直到它的一个子进程退出或收到一个不能被忽视的信号时才被启用

        若调用进程没有子进程或它的子进程已经结束，该函数立即返回。

参数：

        status：函数返回时，参数status中包含子进程退出时的状态信息。

                        子进程的退出信息在一个int中包含了多个字段，

                        用宏定义可以取出其中的每个字段。

                        子进程可以通过exit或_exit函数发送退出状态。

                        以下是一些常用的宏：

                                WIFEXITED(status)：检查子进程是否正常退出。

         WEXITSTATUS(status)：获取子进程的退出状态值。

         WIFSIGNALED(status)：检查子进程是否因收到信号而终止。

         WTERMSIG(status)：获取导致子进程终止的信号编号。

返回值：

        成功：子进程的进程号。

        失败：-1

代码示例：

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


int main()
{
    pid_t pid;
    pid = fork();

    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    if (pid > 0)
    {
        //不接收子进程的退出状态
       // wait(NULL);
        //接收子进程退出状态，子进程中必须用exit或_exit函数退出进程时发送退出状态
        int status = 0;
        wait(&status);
        if (WIFEXITED(status) != 0)
        {
            printf("son process return status:%d\n", WEXITSTATUS(status));
        }
        printf("in pratent proces\n");

    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            printf("in son process\n");
            sleep(1);
        }
        exit(4);
    }
    return 0;
}

执行截图：

waitpid函数

#include<sys/types.h>

#include<sys/wait.h>

pid_t waitpid(pid_t pid, int *status, int options);

功能：

        等待子进程终止，如果子进程终止了，此函数会回收子进程的资源。

参数：

        pid：指定的进程或者进程组。

                pid>0：等待进程ID等于PID的子进程

                pid+0：等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组，waitpid不会等待它。

                pid=-1：等待任一子进程，此时waitpid和wait作用一样。

                pid<-1：等待指定进程组中的任何子进程，这个子进程组的ID等于pid的绝对值

        status：保存子进程退出时的状态信息。

        options：选项

                0：同wait，阻塞父进程，等待子进程退出。

                WNOHANG：没有任何已经结束的子进程，则立即返回。

                WUNTRACED：如果子进程暂停了则此函数马上返回，并且不予以理会子进程的结束状态。（跟踪调试，很少使用）

返回值：

        成功：返回状态改变了的子进程的进程号；如果设置了选项WNOHANG并且pid指定的进程存在，返回0。

        失败：返回-1。当pid指示的子进程不存在，或此进程存在，但不是调用进程的子进程，waitpid 就会出错返回，这时 errno 被设置为 ECHILD。

wait(status)  <==> waitpid(-1, status, 0)

代码示例：

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


int main()
{

    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        waitpid(pid, NULL, 0);
        printf("in father process\n");
    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            printf("in son  process\n");
            sleep(1);
        }
    }
    return 0;
}

 执行截图：

1.3 特殊进程：僵尸进程、孤儿进程、守护进程

  • 僵尸进程（Zombie Process） 进程已运行结束，但进程的占用的资源未被回收，这样的进程称为僵尸进程。 子进程已运行结束，父进程未调用 wait 或 waitpid 函数回收子进程的资源是子进 程变为僵尸进程的原因。
  • 孤儿进程（Orphan Process） 父进程运行结束，但子进程未运行结束的子进程。
  • 守护进程（精灵进程）（Daemon process） 守护进程是个特殊的孤儿进程，这种进程脱离终端，在后台运行。

1.4 进程的终止：exit和_exit函数

exit函数：

#include<stdlib.h>

void exit(int value)

参数：

        status：返回给父进程的参数(低 8 位有效)。

                        一般失败设置为非0，成功设置为0

_exit函数：

#include void _exit(int value)

参数:

        status:返回给父进程的参数(低 8 位有效)。

                一般失败设置为非0，成功设置为0

exit和_exit函数的区别：

  •         exit为库函数，而_exit为系统调用。
  •         exit会刷新缓冲区，但是_exit不会刷新缓冲区
  •         一般使用exit

 代码示例：

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

void fun()
{
    printf("nihao hangzhou");
    //测试return是带换行\n
   // printf("nihao hangzhou\n");
    
    //主函数中退出进程，子函数中退出当前函数。
    //      return  ;
    //退出一个进程，刷新缓冲区
    //exit(0);  
    //退出一个进程，不刷新缓冲区    
    _exit(0);
    printf("welcoom to binjiang\n");
}
int main()
{
    printf("hello world\n");
    fun();
    printf("hello kitty\n");
    return 0;
}

执行截图：

return截图：

exit截图：

 

_exit截图：

 

1.5 进程退出清理：atexit函数

进程在退出前可以使用atexit函数注册退出函数

#include<stdlib.h>

int atexit(void (*function)(void));

功能：

        注册进程正常结束前调用的函数，进程退出执行注册函数。

参数：

        function：进程结束前，调用函数的入口地址。

        一个进程中可以多次调用atexit函数注册清理函数，正常结束前调用函数的顺序和注册时的顺序相反。 

代码示例：

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


void clear_fun1(void)
{
    printf("perform clear fun1 \n");
}
void clear_fun2(void)
{
    printf("perform clear fun2 \n");
}
void clear_fun3(void)
{
    printf("perform clear fun3 \n");
}
int main()
{
    //atexit在进程结束时才会执行对应的回调函数
    //注意调用顺序是反的
    atexit(clear_fun1);
    atexit(clear_fun2);
    atexit(clear_fun3);
    printf("process exit 3 sec later!!!\n");
    sleep(3);
    return 0;
}

执行截图：

1.6 进程的创建 ：vfork函数

vfork函数

#include<sys/types.h>

#include<unistd.h>

pid_t vfork(void)

功能：

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

返回值：

        创建子进程成功，则在子进程中返回0，父进程中返回子进程ID。

        出错返回-1.

fork和vfork函数的区别：

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

        vfork和fork一样都创建一个子进程，但它并不将父进程的地址空间完全复制到子进程中，因为子进程会立即调用exec(或exit),于是也就不访问该地址空间。

        相反，在子进程中调用exec或exit之前，它在父进程的地址空间中运行，在exec之后子进程会有自己的进程空间。

子进程在父进程之前运行

代码示例：

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

int main()
{
    //使用vfork，子进程会先执行，直到子进程执行exit或exec后，父进程才会执行。
    pid_t pid;
    pid = vfork();
    if (pid < 0)
    {
        perror("fail to  vfork");
        exit(1);
    }
    else if (pid > 0)
    {
        while (1)
        {
            printf("in father process\n");
            sleep(1);
        }
    }
    else
    {
        int i = 0;
        for (i = 0; i < 5; i++)
        {
            printf("in son process\n");
            sleep(1);
        }
        exit(0);
    }
    return 0;
}

执行截图：

 子进程与父进程共享一个空间

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

int a = 10;
int main()
{
//父子进程共享一个空间
    pid_t pid;
    int b = 9;
    pid = vfork();
    if (pid < 0)
    {
        perror("fail to vfork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in father process a = %d b = %d\n", a, b);
    }
    else
    {
        a++;
        b++;
        printf("in son process a = %d b = %d\n", a, b);
        exit(0);
    }
    return 0;
}

 执行截图：

2. 进程的替换：exec函数族

exec函数族，是由六个exec函数组成的

  1. exec函数族提供了六种在进程中启动另一个进程的方法
  2. exec函数族可以根据指定的文件名或目录名找到可执行文件
  3. 调用exec函数的进程并不创建新的进程，故调用exec前后，进程的进程号并不会改变，其执行的程序完全由新的程序替换，而新的程序则从其main函数开始执行。

exec函数族取代调用进程的数据段、代码段和堆栈段。

 #include<unistd.h>

int execl(const char *path, const char *arg, .../*(char *) NULL */);

int execlp(const char *file, const char *arg, .../* (char *) NULL */);

int execlv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

int execle(const char *path, const char *arg, .../*, (char *) NULL*/, char *const envp[]);

int execvpe(const char *file, char *const argv[], char *const envp[]);

功能：

        在一个进程里面执行另一个程序，主要用于执行命令。

参数：

        path：命令或者程序的路径。

        l：如果是带l的函数，对应的命令或者程序是通过每一个参数进行传递的，最后一个为NULL表示结束。

                例如："ls","-l",NULL

        v：如果是带v的函数，对应的命令或者程序是通过一个指针数组来传递的，指针数组的最后一个元素为NULL标志结束。

                char *str[] = {"ls", "-l", NULL}；

        p：如果是不带p的函数，第一个参数必须传当前命令或者程序的绝对路径，

              如果是带p的函数，第一个参数既可以是绝对路径，也可以是相对路径。

返回值：

        失败：-1

代码示例：

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


int main()
{
    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        perror("fail to fork");
        exit(1);
    }
    else if (pid > 0)
    {
        printf("in father process\n");
        wait(NULL);
        printf("the soon process has quied\n");
    }
    else
    {
        printf("in son process\n");
#if 0
        if (execl("/bin/ls", "ls", "-l", NULL) == -1)
        {
            perror("fail to execl");
            exit(1);
        }
#endif
#if 0
        if (execlp("ls", "ls", "-l", NULL) == -1)
        {
            perror("fail to execlp");
            exit(1);
        }
#endif
#if 0
        char* str[] = { "ls", "-l",NULL };
        if (execv("/bin/ls", str) == -1)
        {
            perror("fail to execv");
            exit(1);
        }
#endif
#if 0
        if (execlp("./myshell.sh", "./myshell.sh", NULL) == -1)
        {
            perror("fail to execlp");
            exit(1);
        }
#endif
#if 1
        if (execlp("./myshell.sh", "./myshell.sh", NULL) == -1)
        {
            perror("fail to execlp");
            exit(1);
        }
#endif
#if 0
        if (execlp("./hello", "./hello", NULL) == -1)
        {
            perror("fail to execl");
            exit(1);
        }
#endif
#if 0
        if (execl("./hello", "./hello", NULL) == -1)
        {
            perror("fail to execl");
            exit(1);
        }
#endif

        printf("hello world\n");
    }
    return 0;
}
80, 1          Bot

一个进程调用exec后，除了进程ID，进程还保留了下列特征不变：

  • 父进程号
  • 进程组号
  • 控制终端
  • 根目录
  • 当前工作目录
  • 进程信号屏蔽集
  • 未处理信号
  • .....

3. system函数：

#include<stdlib.h>

int system(const char *command);

功能：

        system会调用fork函数产生子进程，子进程调用exec启动/bin/sh -c string来执行参数string字符串所代表的命令，此命令执行完后返回调用进程。

参数：

        要执行的命令的字符串。

返回值：

        如果command为NULL,则system（）函数返回非0，一般为1.

        如果system（）在调用/bin/sh时失败则返回127，其他失败原因返回-1。

注意：

        system调用成功后会返回执行shell命令后的返回值。其返回值可能为1、127也可能为-1，故最好应再检查errno来确认执行成功。

代码示例：

#include<stdio.h>
#include<stlib.h>

int main()
{
    system("clear");
    system("ls -l");
    system("./hello");
    system(. / myshell.sh");

        return 0;
}

总结：

        本章介绍了进程的概念、创建和使用。通过了解进程管理的核心原理，我们可以更好地利用和控制系统资源，实现并发操作，并构建高效的应用程序。深入了解进程的概念和技术，将使我们能够设计出更稳定、可扩展的系统架构，并解决多进程之间的通信和同步问题。

        希望这篇博客能帮助您在应用程序开发过程中更好地理解和应用进程管理的重要性。谢谢阅读！        

SecureCode
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Linux处理机管理——进程详解及代码分析
流楚丶格念的博客
07-27 4194
文章目录Linux处理机管理1.进程1.1.进程的概念1.2.进程的定义1.3.操作系统引入进程概念的原因:1.4.进程的特征2.CPU进程与线程的关系和区别小结：Linux如何查询进程3.如何创建一个进程代码实例补充：UID PID PPIDUIDPIDPPID Linux处理机管理 ​ 操作系统管理功能的主要目标之一一就是提高处理机(CPU)的使用率，使它尽可能处于工作状态.在Linux系统中，提高处理机使用率的技术措施主要是多道和分时，处理机在进程之间切换，按照一定的规则轮流执行每个进程。对于单个处
操作系统进程管理代码
05-14
操作系统进程管理实验代码，主要是进程资源抢占，有关进程优先级
计算机操作系统实验一 进程创建模拟 源代码
01-30
C语言模拟实现操作系统中进程的创建，可以创建一个或者多个子进程，以进程树的形式直观显示。C语言模拟实现操作系统中进程的创建，可以创建一个或者多个子进程，以进程树的形式直观显示。
Linux进程控制（进程创建、进程终止、进程等待、进程替换）
qq_62113644的博客
08-09 455
变成z状态之后呢，然后20秒过后，父进程一醒来，父进程会立马执行这里的位置，它就会把对应的子进程回收掉，所以我们就又会看到z状态就变没了。那么成功的时候，我也可以看一下它等待成功时的返回值。是因为子进程的内核数据结构基本没变，只是重新建立了一下虚拟到物理地址之间的一种映射关系，那么它的内核对应的数据结构没有发生任何变化，包括子进程的pid都不变，子进程的pid不变，那么也就意味着它压根就没有创建新的子进程或者新的进程，它依旧是老的进程，只不过让新的程序执行了不同的让新的进程执行了不同的程序，这就叫做。
Linux进程控制【概念 + 代码演示】
smf12138的博客
11-08 421
创建子进程后，子进程执行的是父进程的代码片段，如果我们想要创建出的子进程，执行全新的代码片段呢？函数是非常重要的函数，它从已存在进程中创建一个新进程，新进程为子进程，而原进程为父进程.如果我们使用fork创建一个子进程，子进程执行程序替换，会不会影响父进程呢？所以，在程序的任意位置调用exit()函数，进程就会立即退出，不会再执行。：若为正常终止子进程返回的状态，则为真（查看子进程是否正常退出）函数内部拿出子进程的退出信息，那么，它具体是从哪里拿到的呢？，不予以等待，若正常结束，则返回该子进程的。
Linux进程概念&&僵尸进程&&孤儿进程
分享C/C++/Linux/网络/数据库/数据结构
03-11 1771
Linux进程概念&&僵尸进程&&孤儿进程
进程控制的理解和板书演示
weixin_58843717的博客
04-28 391
这篇博客是对于进程控制的完整篇，有进程创建、进程中止、进程等待、进程程序替换的相关概念理解和图片的形式进行的测试演示便于理解。 文章目录一、进程创建二、进程中止1. 进程退出场景2. 进程中止3. 进程退出方式4. 进程退出的作用三、进程等待1. 是什么？2. 为什么让父进程等待呢？3. 如何进程等待？僵尸进程回收的演示4. waitpid()介绍和简单使用(1).第一个参数是进程pid(2)第二个参数status（得到退出信息）如何获取子进程的退出信息？父进程拿到什么status结果，一定和子进程如何退出
理解进程信号
冯同学的博客
05-12 591
理解Linux中信号的产生方式、产生过程、处理方式，以及处理方式有哪些。理解什么是捕捉信号，捕捉后在什么时候进行处理。深入理解在什么时候进行信号检测。理解什么是信号集，如何操作信号集，以及相关的操作信号集的函数
Linux进程控制（精讲）
热门推荐
2021dragon的博客
10-01 2万+
文章目录进程创建fork函数初始fork函数返回值写时拷贝fork常规用法fork调用失败的原因进程终止进程退出场景进程常见退出方法_exit函数exit函数return退出进程等待进程等待的必要性进程等待的方法wait方法waitpid方法获取子进程status具体代码实现进程程序替换替换原理替换函数函数解释命名理解做一个简易的shell 进程创建 fork函数初始 fork函数返回值 写时拷贝 fork常规用法 fork调用失败的原因 进程终止 进程退出场景 进程常见退出方法 _exit函数 exit函
Linux系统与进程有关的系统调用
m0_54002804的博客
11-20 2637
本文主要展示了如下系统调用的使用说明，并做了演示程序。 getpid getppid fork waitpid exec 文章目录一、进程相关的系统调用1.查询进程的ID2.创建进程3.进程资源回收4.进程退出二、 exec()函数族二、示例程序1.示例程序12.示例程序2 一、进程相关的系统调用 1.查询进程的ID getpid返回当前进程的pid，getppid则返回当前进程父进程的pid。 pid_t实质上是int类型 头文件以及函数声明如下： #include <sys/t
oracle多进程编程,编写多进程程序及其代码
weixin_30210749的博客
04-09 321
实验目的通过编写多进程程序，熟练掌握fork()、exec()、wait()和waitpid()等函数的使用，进一步理解在Linux中多进程编程的步骤。实验内容该实验有3个进程，其中一个为父进程，其余两个是该父进程创建的子进程，其中一个子进程运行“ls -l”指令，另一个子进程在暂停5s后异常退出。父进程先用阻塞方式等待第一个进程的结束，然后用非阻塞方式等待另一个子进程的退出，待收集到第2个子进程...
Linux相关指令
m0_46502962的博客
07-25 144
其中的-lpthread不是必须的，只有用到该库才输入加上。//该指令将demo.c生成的a.out文件命名为demo8。//将运行结果放到test.ret.txt文件中，没有就创建。1.查看手册 man 3 free。将该运行程序放到后台运行。③(gbd)r 运行。④(gbd)q 退出。
Linux Vim教程：多文件编辑与窗口管理
07-25 868
Vim作为一款功能强大的文本编辑器，支持多文件编辑和窗口管理。掌握这些高级技巧可以大大提高工作效率和文件处理能力。本文将详细介绍Vim中多文件编辑与窗口管理的各种方法和技巧，包括缓冲区、标签页、分屏、快速切换等。通过这些实用技巧，您可以更高效地在Vim中进行复杂的文本编辑任务。
linux上导出数据库
weixin_43652507的博客
07-24 283
linux上导出数据库 MySQL、PostgreSQL、SQLite、MongoDB
Linux下pip的安装、命令总结、换源
2301_79695159的博客
07-24 525
Linux下pip的安装、命令总结、换源
【Linux】 Linux makefile 教程
沐风—云端行者
07-23 696
什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。因为，makefile关系到了整个工程的编译规则。一个工程中的源文
Linux守护进程daemon与服务service及systemctl命令的作用
最新发布
云计算课代表
07-25 285
守护进程 daemon 是指后台运行的进程，随系统启动而为应用程序提供支持， 而服务 service 则用于提供某种功能。用 systemctl 命令对服务来完成启动、关闭、重启等操作。
linux设置～/.vimrc步骤
qq_43982499的博客
07-24 491
set backupdir=~/.vim/backup " 设置备份文件存放路径。set tabstop=4 " 设置Tab键宽度为4个空格。set shiftwidth=4 " 设置自动缩进宽度为4个空格。set undodir=~/.vim/undo " 设置撤销历史文件存放路径。set hlsearch " 搜索结果高亮显示。set fileformat=unix " 设置文件格式为Unix风格。
实模式下进程调度实现：汇编代码详解
"该资源提供了一个使用nasm编写的进程调度的实例，包含详细注释，旨在演示在实模式下如何通过计时器实现多进程的简单切换。实验中，loader.asm程序被用来加载内核kernel.bin以及a.bin、b.bin、c.bin三个应用程序，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SecureCode

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值