Linux进程控制

于 2024-10-08 13:32:52 发布
阅读量858 收藏 18
点赞数 23
分类专栏： Linux 文章标签： linux 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/142757292
版权

目录

Linux进程控制

进程创建

进程终止

进程回收

进程退出信息

子进程使用案例

阻塞与非阻塞

进程程序替换

介绍

原理简单解释

手撕一个简单的Shell

Linux进程控制

进程创建

在Linux进程基础篇已经提到过使用fork函数创建一个子进程。

回想使用fork函数时，其返回值当子进程创建失败时，父进程接收到-1；当子进程创建成功时，则对于子进程来说接收到的返回值为0，而父进程接收到的返回值为子进程的PID

其原因现在也可以解释：前面提到当子进程不修改与父进程共享的数据时，子进程和父进程拥有同一块数据空间，但是因为fork函数创建完子进程后，函数会对两个进程的同一块区域的数据进行修改，导致子进程拥有的是一块新的空间，并在新的空间中写入0，而父进程依旧对应原来的空间，并在原空间中写入子进程的PID

以上便是在代码中创建子进程的步骤

进程终止

前面在父进程中创建子进程只满足了创建，并没有满足终止。在程序中，如果想终止一个进程，可以使用三种方式：

  1. main函数中return
  2. 在代码任何位置使用exit()函数，参数可以是任意整数
  3. 在代码任何位置使用_exit()函数，参数可以是任意整数
第二个方式和第三个方式与第一个方式最大的不同：第一个方式只会结束某一个函数，而第二个方式和第三个方式会直接结束一个进程

之前C语言部分介绍过：在不同的系统和C语言标准库的实现中都规定了一些错误码，一般是放在 errno.h 这个头文件中说明的，C语言程序启动的时候就会使用一个全局变量errno来记录程序的当前错误码，只不过程序启动的时候errno是0，一般0表示没有错误，而非0表示存在错误。当我们在使用标准库中的函数的时候发生了某种错误，就会将对应的错误码存放在errno中，而一个错误码的数字是整数很难理解是什么意思，所以每一个错误码都是有对应的错误信息的，但是不同的操作系统会存在不同的错误码和错误信息，为了更方便的显示指定的错误码对应的错误信息，可以使用strerror函数，参数传递errno变量或者指定的错误码。除了标准库中已经定义的错误，也可以约定某些错误码表示某种错误

不论是库或者系统已经提供的错误码，还是自定义的错误码都可以作为exit函数和_exit函数的参数传递

但是，exit函数和_exit函数存在细微的差别：exit函数在结束进程时，会刷新进程的缓冲区，但是_exit函数不会，例如下面的代码：

// 使用exit函数
#include <stdio.h>
#include <stdlib.h>

void fun() {
    printf("函数退出");
    exit(1);
}

int main(){
    fun();
    printf("进程正常退出\n");
    
    return 0;
}

输出结果：
函数退出

// 使用_exit函数
#include <stdio.h>
#include <unistd.h>

void fun() {
    printf("函数退出");
    _exit(1);
}

int main(){
    fun();
    printf("进程正常退出\n");
    
    return 0;
}

无输出结果

因为exit函数是基于系统调用接口的函数，属于语言层面的函数，而_exit函数是系统的调用接口函数，前面提到\n可以刷新缓冲区，所以可以推断出，此处所谓的缓冲区实际上是语言级别的缓冲区。_exit函数在操作系统内部运行，并不知道有缓冲区的存在，自然也就无法刷新该缓冲区，对应的exit函数是语言层面的函数，对应的缓冲区是语言层的缓冲区，所以可以做到缓冲区刷新

可以认为 exit函数底层调用了 _exit函数和 fflush函数

在进程结束部分提到过，可以使用echo $?获取最近一次结束的进程的退出码，所以此处也可以获取到通过return、exit或者_exit结束的进程返回值，查看上面的代码进程的退出码如下：

进程回收

在前面创建子进程中，并没有提到如何回收子进程，一旦子进程在父进程结束之前结束，子进程便会一直处于僵尸状态等待父进程回收，如果一直不回收便一直处于僵尸状态导致内存泄漏。在Linux，如果需要父进程对子进程进行回收，避免持续僵尸可以使用下面的两种方式：

  1. 使用wait()函数，该函数会等到任意子进程执行结束之后回收该子进程，再执行该函数后面的代码，参数传递一个用于接收子进程状态的状态变量地址，函数返回回收的子进程的PID
  2. 使用waitpid()函数，同wait函数，但是该函数可以指定接收的进程，第一个参数传递需要回收的子进程的PID，第二个参数传递用于回收的子进程状态的状态变量地址，第三个参数传递指定函数的行为，函数返回回收的子进程的PID
如果 waitpid函数第一个参数传递一个大于0的数（即子进程 PID），则回收指定的进程，如果传递-1，则作用等同于 wait函数

基本使用如下：

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

int main(){
    printf("父进程pid: %d\n", getpid());
    pid_t id = fork();
    
    if(id == 0) {
        int cnt = 5 ;
        while(cnt--) {
            printf("子进程pid: %d\n", getpid());
            sleep(1);
        }

        exit(0);
    } else {
        sleep(10);
        pid_t ret = wait(NULL);
        while(1) {
            printf("父进程pid: %d\n", getpid());
            sleep(1);
        }
    }

    return 0;
}

为了更好得监视执行时子进程的变化，可以使用下面的Shell脚本每隔一秒进行一次监视：

while :; do sleep 1; ps ajx | head -1 && ps ajx | grep process; done

编译运行上面的代码后，可以看到下面的效果：

使用waitpid函数可以修改为如下代码，效果同上面的代码：

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

int main(){
    printf("父进程pid: %d\n", getpid());
    pid_t id = fork();
    
    if(id == 0) {
        int cnt = 5 ;
        while(cnt--) {
            printf("子进程pid: %d\n", getpid());
            sleep(1);
        }

        exit(0);
    } else {
        sleep(10);
        pid_t ret = waitpid(id, NULL, 0);
        while(1) {
            printf("父进程pid: %d\n", getpid());
            sleep(1);
        }
    }

    return 0;
}

如果需要回收子进程的状态，可以通过状态变量接收，因为waitpid函数的第二个参数相当于一个输出型参数：

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

int main(){
    printf("父进程pid: %d\n", getpid());
    pid_t id = fork();
    int status = 0;

    if(id == 0) {
        int cnt = 5 ;
        while(cnt--) {
            printf("子进程pid: %d\n", getpid());
            sleep(1);
        }

        exit(0);
    } else {
        sleep(10);
        pid_t ret = waitpid(id, &status, 0);
        while(1) {
            printf("父进程pid: %d, status = %d\n", getpid(), status);
            sleep(1);
        }
    }

    return 0;
}

如果上面子进程的退出码为非0，那么status中的值可能会有所不同，代码如下：

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

int main(){
    printf("父进程pid: %d\n", getpid());
    pid_t id = fork();
    int status = 0;

    if(id == 0) {
        int cnt = 5 ;
        while(cnt--) {
            printf("子进程pid: %d\n", getpid());
            sleep(1);
        }

        exit(1);
    } else {
        sleep(10);
        pid_t ret = waitpid(id, &status, 0);
        while(1) {
            printf("父进程pid: %d, status = %d\n", getpid(), status);
            sleep(1);
        }
    }

    return 0;
}

运行上面的代码效果如下：

在上面的代码中，子进程的退出码是1，但是status中存储的却是256，因为在Linux中，一个进程退出一般不仅仅包含退出码，还有其他内容，这些内容统称为为进程退出信息。

进程退出信息

下面主要讨论两种进程退出信息：

  1. 进程退出码
  2. 进程退出信号

在Linux中，存在一个整型值status，该值存储了进程的相关退出信息，一般情况下，一个整型值占用4个字节，所以在status中，低两个字节（比特位从9到15）存储的就是进程退出码（占用8-15）和进程退出信号（占用0-7），示意图如下：

第8位比特位存储的core dump标志，具体见后续讲解

所以在上面的代码中，进程退出码设置为1，实际上是在第9位比特位设置为1，即0000001，但是因为进程是正常退出的，所以进程信号部分为全0，core dump此时也为0，就出现了000000100000000，所以此时获取到的status就是256

如果想要直接获取进程退出码可以使用下面的思路：

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

int main(){
    printf("父进程pid: %d\n", getpid());
    pid_t id = fork();
    int status = 0;

    if(id == 0) {
        int cnt = 5 ;
        while(cnt--) {
            printf("子进程pid: %d\n", getpid());
            sleep(1);
        }

        exit(1);
    } else {
        sleep(10);
        pid_t ret = waitpid(id, &status, 0);
        while(1) {
            printf("父进程pid: %d, status = %d\n", getpid(), (status>>8)&255);
            sleep(1);
        }
    }

    return 0;
}
上面的代码中，使用了 (status>>8)&255取出进程退出码，注意尽管已经将 status 右移 8 位把高 8 位移到低 8 位的位置，但是为了保证其他位置为0，需要与255进行 &运算

在Linux中，进程退出码一般即为0或者errno中的值，也可以是自定义的整数值，而进程退出信号中0表示正常退出，其他对应着不同的进程退出信号，如下图所示：

例如信号8和信号11：

// 信号8
#include <stdio.h>

int main()
{
    int a = 1 / 0;

    return 0;
}

运行后：
Floating point exception

// 信号11
#include <stdio.h>

int main()
{
    int* a = NULL;
    *a = 1;

    return 0;
}

运行后：
Segmentation fault

这些退出信号默认由操作系统检测并向进程发出，所以当用户看到进程退出信号时，其实操作系统在这之前已经终止了进程，这种进程退出也被称为进程异常退出。至此，在Linux中，进程退出一共有三种情况：

  1. 进程代码执行完成，进程退出码为0，进程退出信号为0，正常退出
  2. 进程代码执行完成，进程退出码为非0，进程退出信号为0，正常退出但是程序出现逻辑问题导致指定任务未完成
  3. 进程代码未执行完成，进程退出信号为非0，进程异常退出

对于子进程出现进程退出信号非0，也可以通过下面的方式获取对应的进程退出信号：

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

int main(){
    printf("父进程pid: %d\n", getpid());
    pid_t id = fork();
    int status = 0;

    if(id == 0) {
        int cnt = 5 ;
        while(cnt--) {
            printf("子进程pid: %d\n", getpid());
            sleep(1);
        }

        int a = 1 / 0;

        exit(1);
    } else {
        sleep(10);
        pid_t ret = waitpid(id, &status, 0);
        while(1) {
            printf("父进程pid: %d, status = %d\n", getpid(), status&255);
            sleep(1);
        }
    }

    return 0;
}

除了操作系统可以向进程发送进程退出信号，用户也可以通过kill指令向进程发送对应的退出信号，使用方式与使用kill结束进程一致

上面获取进程退出信息的方式稍微有点繁琐，在Linux中，有对应的宏可以帮助获取到指定的进程退出信息：

例如下面的代码：

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

int main(){
    printf("父进程pid: %d\n", getpid());
    pid_t id = fork();
    int status = 0;

    if(id == 0) {
        int cnt = 5 ;
        while(cnt--) {
            printf("子进程pid: %d\n", getpid());
            sleep(1);
        }

        // int a = 1 / 0;

        exit(1);
    } else {
        // sleep(10);
        pid_t ret = waitpid(id, &status, 0);
        if (WIFEXITED(status)) // 进程正常退出时
        {
            printf("父进程pid: %d, status = %d\n", getpid(), WEXITSTATUS(status)); // 获取进程的退出码
        } else if(WIFSIGNALED(status)) {
            printf("父进程pid: %d, status = %d\n", getpid(), WTERMSIG(status)); // 否则获取进程的退出信号
        }
    }

    return 0;
}

在Linux源码中，PCB中存在着两个变量分别存储着进程退出码和进程退出信号：

struct task_struct {
    // ...
    int exit_code, exit_signal;
    // ...
};

子进程使用案例

前面的子进程都只是完成一些简单的打印工作，现在可以通过子进程完成一些其他工作，实现子进程执行其他任务的效果：

目标：父进程向容器中添加数据，而子进程将数据保存到指定的文件中

示例代码如下：

#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

// 定义全局变量
vector<int> data;

int _save() {
    ofstream ofs("content.txt", ios::out | ios::trunc);
    stringstream ss;
    string value;
    // 将内容转换成字符串
    for(auto num : data) {
        ss << num;
        value += ss.str() + " ";
        ss.str("");
    }

    // 写入文件
    ofs << value;

    return 0;
}

void save() {
    // 创建子进程
    pid_t id = fork();

    if (id == 0) {
        // 子进程执行保存
        int code = _save();
        //子进程退出
        exit(code);
    }

    // 父进程回收子进程
    waitpid(id, nullptr, 0);
}

int main() {
    int count =  0;
    // 持续向容器中存入数据
    while(true) {
        data.push_back(count+1);
        // 如果已经添加了10次，则子进程执行保存
        if (count++ % 10 == 0) {
            save();
        }
        cout << count << endl;
        sleep(1);
    }

    return 0;
}

阻塞与非阻塞

在上面的子进程案例中，每一次子进程在执行任务时，父进程都需要等待子进程执行完毕后回收子进程才可以继续执行父进程的代码，这个过程中父进程处于阻塞等待状态

但是如果希望父进程在子进程还在执行的时候一边等待子进程结束，一边执行自己的任务就需要让父进程处于非阻塞等待状态

需要使用非阻塞状态就需要设置waitpid第三个参数为WNOHANG，此时waitpid的返回值从原来的两种（大于0和等于-1）变为三种（大于0、等于0和等于-1），此时大于0表示已经回收到对应的子进程的PID，等于0说明子进程还在执行需要继续等待，等于-1说明回收失败

因为非阻塞等待无法确定子进程何时等待，所以需要手动循环持续等待

使用非阻塞等待修改前面的案例代码：

#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

vector<int> data;

int _save() {
    ofstream ofs("content.txt", ios::out | ios::trunc);
    stringstream ss;
    string value;
    // 将内容转换成字符串
    for(auto num : data) {
        ss << num;
        value += ss.str() + " ";
        ss.str("");
    }

    // 写入文件
    ofs << value;

    return 0;
}

void save() {
    // 创建子进程
    pid_t id = fork();

    if (id == 0) {
        // 子进程执行保存
        int code = _save();
        //子进程退出
        exit(code);
    }

    // 使用非阻塞等待
    while(true) {
        pid_t ret = waitpid(id, nullptr, WNOHANG);
        if(ret > 0) {
            cout << "子进程回收成功" << endl;
            return;
        } else if (ret == 0) {
            cout << "子进程还在运行" << endl;
        } else {
            cout << "回收失败" << endl;
            return;
        }
        sleep(1);
    }
}

int main() {
    int count =  0;
    // 持续向容器中存入数据
    while(true) {
        data.push_back(count+1);
        // 如果已经添加了10次，则子进程执行保存
        if (count++ % 10 == 0) {
            save();
        }
        cout << count << endl;
        sleep(1);
    }

    return 0;
}

进程程序替换

介绍

前面子进程在完成任务都是基于分支语句中属于子进程的代码，而进程程序替换的作用就是为了让子进程执行其他程序的代码和数据

在Linux中，有七个可以调用其他程序的函数，如下：

// C语言封装的接口
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., 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[]);
// 系统接口
int execve(const char *filename, char *const argv[], char *const envp[]);

参数解释：

  1. const char *path：执行的目标程序的路径
  2. const char *arg, ...：如何执行目标程序，一般传入的内容与命令行执行对应程序时输入的内容相同，例如ls -a -l，参数写为"ls", "-a", "-l", "nullptr/NULL"（需要传入nullptr或者NULL是因为命令行参数表以nullptr/NULL结尾）
  3. char *const argv[]：如何执行目标程序，与const char *arg, ...不同的是，char *const argv[]接收的是一个数组，所以需要额外创建一个数组，而数组中的内容即为命令行参数，以nullptr或者NULL作为最后一个字符串
  4. const char *file或者const char *filename：执行的目标程序名称（不需要路径）
  5. char * const envp[]：需要传递的环境变量，与char *const argv[]使用基本一致，一般有新的环境变量时才会使用本参数

函数返回值解释：

上面所有的函数当正常调用程序时，返回-1，否则没有返回值

下面以三种函数为例：

共用的Makefile文件如下：

TARGET=process 
SRC=process.c

$(TARGET):$(SRC)
    gcc $^ -o $@

.PHONT:clean
clean:
    rm -f $(TARGET)
  1. int execl(const char *path, const char *arg, ...)
#include <stdio.h>
#include <unistd.h>

int main()
{
    execl("/usr/bin/ls", "ls", "--color", "-a", "-l", NULL);

    return 0;
}

运行结果：

  1. int execvp(const char *file, char *const argv[])
#include <stdio.h>
#include <unistd.h>

int main()
{
    char* const argv[] = {
       (char*) "ls",
       (char*) "--color",
       (char*) "-a",
       (char*) "-l",
        NULL
    };
    execvp("ls", argv);
    return 0;
}

运行结果：

上面的代码中，使用 (char*)是为了将字符串的类型 (const char*)强制转换为 char*，从而类型匹配以消除编译器警告

也可以使用下面的更安全的方式：

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

int main()
{
    char cmd[] = "ls";
    char opt1[] = "--color";
    char opt2[] = "-a";
    char opt3[] = "-l";
    char* const argv[] = { cmd, opt1, opt2, opt3, NULL };

    execvp("ls", argv);
    return 0;
}
  1. int execvpe(const char *file, char *const argv[], char *const envp[])
#include <stdio.h>
#include <unistd.h>

int main()
{
    char cmd[] = "ls";
    char opt1[] = "--color";
    char opt2[] = "-a";
    char opt3[] = "-l";
    char* const argv[] = { cmd, opt1, opt2, opt3, NULL };
    
    char newEnv[] = "newEnviron=10000";
    
    char* const envp[] = {newEnv, NULL};

    execvpe("ls", argv, envp);
    
    return 0;
}

运行结果：

如果需要添加环境变量到当前系统的环境变量并以新的系统环境变量执行，可以使用下面的代码：

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

extern char** environ;

int main()
{
    char cmd[] = "ls";
    char opt1[] = "--color";
    char opt2[] = "-a";
    char opt3[] = "-l";
    char* const argv[] = { cmd, opt1, opt2, opt3, NULL };
    
    char newEnv[] = "newEnviron=10000";
    putenv(newEnv);
    
    execvpe("ls", argv, environ);
    
    return 0;
}
此处 char**和 char* []是兼容的类型，都表示一个指向字符串指针的指针数组，所以可以将 char** environ传递给 char* const envp[]参数，因为两者在内存布局上是相同的

原理简单解释

进程程序替换的本质是将进程对应的虚拟地址空间中的代码和数据替换为指定的程序的代码和数据，从而可以执行其他程序，示意图如下：

因为发生了覆盖，所以一旦执行了exec家族的函数，则该函数后面的代码都会被覆盖从而无法再执行，除非exec家族函数执行失败返回-1

但是需要注意的是，因为是直接覆盖，所以这个过程中exec函数并不会创建一个新进程，运行下面的代码可以证明（只要PID相同，就说明不是新进程执行的exec函数中的程序）：

// 调用程序
#include <stdio.h>
#include <unistd.h>

int main()
{
    printf("当前进程pid为%d\n", getpid());
    execl("./other", "other", NULL); 

    return 0;
}

// 被exec调用程序
#include <stdio.h>
#include <unistd.h>

int main() 
{
    printf("当前进程pid为%d\n", getpid());

    return 0;
}

输出结果：
当前进程pid为4408
当前进程pid为4408
需要注意，上面的 execl第二个参数不用使用 ./other，此处只需要使用 other即可，因为已经指定了路径

前面提到大部分运行在bash上的进程都是bash子进程，所以bash执行子进程的本质就是调用了exec家族函数，而之所以没有覆盖bash原有的进程，就是因为bash开辟了一个子进程再在子进程中调用了exec家族函数。所以可以模仿bash的方式使用多进程，让子进程执行exec家族函数：

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

int main()
{
    pid_t id = fork();
    if(id == 0) {
        execl("/usr/bin/pwd", "pwd", NULL);
        printf("正常执行exec不会执行本语句\n");
    }

    waitpid(id, NULL, 0);
    printf("父进程代码未被覆盖\n");

    return 0;
}

输出结果：
/home/epsda/test_alter_process
父进程代码未被覆盖

有了进程程序替换，进程的独立性更加明显，原因如下：

  1. 完全替换进程映像：当一个进程调用exec系列函数时，它的当前进程映像被新程序替换，除了进程PID和一些资源之外，原进程的代码、数据和堆栈都被新程序的内容替换。这意味着新程序完全独立于调用exec之前的程序
  2. 资源独立性：尽管新程序继承了原进程的文件描述符和环境变量，但它使用的是自己的代码和数据，这使得程序的执行和行为是独立的，不会受到原程序的影响
  3. 内存空间独立：exec调用后，新程序运行在独立的内存空间中，之前的内存内容被清除，新程序的运行不受之前程序的内存内容的影响
  4. 进程控制：调用exec后，原进程的执行流被终止，新程序开始执行。控制权完全交给新程序，使得新程序在执行和资源管理上是独立的

手撕一个简单的Shell

待更新

怡晗★
关注
专栏目录
深剖 Linux 进程控制
qq_61500888的博客
08-19 6669
带你一命通关 Linux 进程控制 十五分钟手撕进程控制原理
Linux进程控制（精讲）
热门推荐
2021dragon的博客
10-01 2万+
文章目录进程创建fork函数初始fork函数返回值写时拷贝fork常规用法fork调用失败的原因进程终止进程退出场景进程常见退出方法_exit函数exit函数return退出进程等待进程等待的必要性进程等待的方法wait方法waitpid方法获取子进程status具体代码实现进程程序替换替换原理替换函数函数解释命名理解做一个简易的shell 进程创建 fork函数初始 fork函数返回值 写时拷贝 fork常规用法 fork调用失败的原因 进程终止 进程退出场景 进程常见退出方法 _exit函数 exit函
操作系统——Linux 进程控制
CSH__的博客
06-25 1519
操作系统课设：实验二
Linux进程控制实验
qq_43796170的博客
11-22 4439
实验1：该实验有3个进程，其中一个为父进程，其余两个是该父进程创建的子进程，其中一个子进程运行“ls -l”指令，另一个子进程在暂停5s之后异常退出，父进程先用阻塞方式等待第一个子进程的结束，然后用非阻塞方式等待另一个子进程的退出，待收集到第二个子进程结束的信息，父进程就返回。 实现代码： /waitpid.c/ #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <s
linux进程控制实验原理,实验三 Linux进程的创建与控制
weixin_34439836的博客
04-28 2155
实验三 Linux进程的创建与控制一、实验目的(1)加深对进程概念的理解，明确进程和程序的区别。(2)进一步认识并发执行的实质。(3)分析进程竞争资源现象，学习解决进程互斥的方法。(4)了解Linux系统中进程通信的基本原理。二、实验预备内容阅读Linux的fork.c源文件，分析进程的创建过程。三、实验内容1. 进程的家族关系在主程序中用3个fork()调用，最后输出一个字符或字符串，运行此简单...
linux进程控制实验心得,Linux学习心得12-进程管理
weixin_31971181的博客
04-28 2390
Linux操作系统包括三种不同类型的进程，每种进程都有自己的特点和属性：交互进程:由shell启动的进程。批处理进程:这种进程和终端没有联系，是一个进程序列。守护进程:在后台持续运行的进程。前台启动:一般地，用户键入一个命令，就已经启动了一个前台的进程。后台启动 :对于非常耗时进程，可以然进程在后台运行。从后台启动进程其实就是在命令结尾加上一个“&”号每个进程，都会对应一个父进程，而这个父...
实验五 linux进程控制,实验五 Linux进程管理和打印管理
weixin_28904055的博客
05-01 1826
实验五 Linux进程管理和打印管理实验五 Linux进程管理和打印管理一. 一. 实验目的：1． 1． 进行系统进程管理。2． 2． 配置Linux下的打印服务器，实现局域网内的Linux和Windows客户端共享使用服务器的打印机。二. 二. 实验内容：1． 1． 进程状态查看；2． 2． 控制系统中运行的进程；3． 3． 安排一次性和周期性自动执行的后台进程；4． 4...
实验四 linux进程控制实验报告,Linux系统进程控制操作系统实验报告4
weixin_42500369的博客
05-02 1510
实验课程名称：操作系统实验项目名称Linux系统进程控制实验成绩实验者专业班级组别同组者实验日期年月日第一部分：实验分析与设计(可加页)实验内容描述(问题域描述)要求：掌握Linux系统中进程控制原语fork( )、sleep( )、wait( )、exit( )、exec的使用方法。内容：在Linux系统中编写C程序，创建一个子进程。父进程和子进程交替运行。父进程先显示一次“Current ti...
Linux进程控制（详解）
梅山
03-26 4997
内容来自：爱编程的大丙 1. 进程概述 从严格意义上来讲，程序和进程是两个不同的概念，他们的状态，占用的系统资源都是不同的。 程序：就是磁盘上的可执行文件, 并且只占用磁盘上的空间，是一个静态的概念。 进程：被执行之后的程序叫做进程，不占用磁盘空间，需要消耗系统的内存，CPU资源，每个运行的进程的都对应一个属于自己的虚拟地址空间，这是一个动态的概念。 1.1 并行和并发 CPU时间片 CPU在某个时间点只能处理一个任务，但是操作系统都支持多任务的，那么在计算机CPU只有一个和的情况下是怎么完成多任务处理的呢
Linux进程控制详解及实例
09-15
Linux进程控制是操作系统的核心组成部分，它允许用户和系统创建、管理以及终止进程。在这个主题中，我们将深入探讨几个关键的Linux进程控制函数，包括fork()、exec家族、wait()和exit()，并提供实例来解释它们如何...
linux进程控制演示代码.rar_Linux kill_Linux 进程控制_researchfoc_进程控制
09-23
`fork`, `kill`, 和 `waitpid` 是三个关键的系统调用，它们在Linux进程控制中扮演着至关重要的角色。这里我们将深入探讨这三个概念以及它们在实际编程中的应用。 1. **fork()**: `fork` 是一个特殊的系统调用，用于...
Linux 进程控制与进程互斥（附源代码）（附实验报告）
03-07
1、利用fork函数创建新进程，并根据fork函数的返回值，判断自己是处于父进程还是子进程中； 2、在新创建的子进程中，使用exec类的函数启动另一程序的执行；...5、分析Linux系统下多进程与多线程中的区别。
嵌入式linux应用开发-linux进程控制开发
09-18
嵌入式linux应用开发-linux进程控制开发 1 基本概念 Linux中最主要的进程表示有进程号（PID）和它的父进程号（PPID），均是非零的正整数。 Linux中获得当前进程的PID和PPID的系统调用函数为getpid和getppid。...
Linux 再入门整理：详解 /etc/fstab 文件
一只奋斗的猪
10-01 1311
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
[Linux]从零开始的网站搭建教程
c858845275的博客
10-02 1373
讲解了如何搭建运维面板安装web服务器和搭建一个自己的网站。
【Linux】进程地址空间(初步了解)
最新发布
weixin_69380220的博客
10-04 1411
进程虚拟地址空间相关内容
【Linux】进程+权限管理+软硬链接+其他命令
weixin_71491685的博客
10-01 1304
cat /etc/passwd 用户信息文件，用户列表（用户名、用户密码占位符、用户编号uid、用户所在组的编号gid、用户备注说明、用户家目录位置、用户的登陆方式）（8）删除软链接并不影响被指向的文件，但若被指向的原文件被删除，则相关软连接被称为死链接（即 dangling link，若被指向路径文件被重新创建，死链接可恢复为正常的软链接）。ps -aux (用户、进程编号、cpu使用率、内存使用率、虚拟内存的大小、真实内存的大小、终端、状态、启动时间、运行时长）
黑马linux笔记（转载）
pscool的博客
10-01 1934
我们所熟知的计算机是由硬件和软件组成的。计算机系统中由电子、机械和光电元件等组成的各种物理装置的总称。（看的见、摸得着的东西：CPU、内存硬盘、显示屏、鼠标等）是用户和计算机硬件之间的接口和桥梁，用户通过软件和计算机进行交流。（操作系统，就是软件的一类）学习Linux系统，就需要有一个可用的Linux系统。由于Linux系统并不适合日常办公使用，所以我们需要借助虚拟机来获得可用的Linux系统环境进行学习。借助虚拟化技术，我们可以在系统中，通过软件：模拟计算机硬件，并给虚拟硬件安装真实的操作系统。
Linux 进程控制
07-01
Linux 进程控制是操作系统管理执行中的程序或线程的一种核心功能。它涉及到创建、调度、同步、通信和终止进程等多个方面。以下是一些关键概念： 1. **进程创建**：在Linux中，可以通过fork()和execve()系统调用来创建新进程。fork()用于创建一个与父进程几乎完全相同的子进程，而execve()则替换进程的正文区域并运行新的程序。 2. **进程ID（PID）**：每个Linux进程都有一个唯一的进程ID，用于标识和跟踪它的生命周期。 3. **进程调度**：Linux使用一种称为" Completely Fair Scheduler"（CFS）的调度算法，根据优先级、CPU使用时间和其他因素公平地分配CPU时间片给各个进程。 4. **进程状态**：进程有多种状态，如新建、运行、就绪、睡眠、阻塞和结束等。可以通过ps命令查看进程状态。 5. **信号处理**：Linux提供信号机制，允许发送信号来通知进程某个事件，如定时器到期、键盘中断等。 6. **进程同步**：互斥锁（mutex）、信号量（semaphore）和条件变量（condition variable）等工具帮助进程间协调操作，避免数据竞争。 7. **进程间通信（IPC）**：有多种方法实现进程间的通信，如管道（pipe/fifo）、消息队列、共享内存和套接字等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

怡晗★

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

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

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

打赏作者

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

抵扣说明：

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

余额充值