Linux进程控制

已于 2024-03-27 19:44:35 修改
阅读量603 收藏 9
点赞数 10
文章标签： linux
于 2024-03-23 00:39:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66442539/article/details/136951846
版权

进程创建

fork 函数
在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。
#include <unistd.h>
pid_t fork(void);
返回值：子进程中返回0，父进程返回子进程id，出错返回-1

进程调用fork，当控制转移到内核中的fork代码后，内核做：

进程:内核的相关管理数据结构(task_struct+mm_struct+页表)+代码(共享)和数据(写时拷贝)

fork 常规用法
一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求
一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数
fork 调用失败的原因
系统中有太多的进程
实际用户的进程数超过了限制

进程终止

终止是在做什么？

释放曾经的代码和数据所占据的空间

释放内核数据结构 

（注意：僵尸进程不会释放内核数据结构，只释放代码和数据所占据的空间）

进程退出场景

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止

进程常见退出方法

正常终止

（可以通过 echo $? 查看最近一个子进程退出码）
1. 从main返回 (return)
2. 调用exit
3. _exit

父进程bash获取到最近一个子进程退出的退出码

告诉父进程，子进程的任务完成的怎么样，知道子进程(成功，失败：原因)

0：代表成功

!0：代表失败，[0-255]:不同的失败原因 

退出码可以用系统的，也可以自定义退出码

return

非main函数return，函数结束

我们平时所写的main函数return 0是我们默认我们的函数运行正确，实际上内部需要判断再进行返回给bash的

exit

我们的代码任意位置调用exit，都表示进程退出

参数：status 定义了进程的终止状态，父进程通过wait来获取该值

exit最后会调用_exit, 但在调用_exit之前，还做了其他工作：
1. 执行用户通过 atexit或on_exit定义的清理函数。
2. 关闭所有打开的流，所有的缓存数据均被写入
3. 调用_exit
_exit

void _exit(int status);

参数： status 定义了进程的终止状态，父进程通过 wait 来获取该值
相比exit，_exit不会刷新缓冲区

异常终止

操作系统发现了你的进程做了不该做的事，OS杀了进程

一旦出现异常，退出码就没有意义了

进程出现异常，本质是：因为进程收到了OS发给进程的信号

段错误，OS提前终止了进程

我们可以看进程退出的时候，退出信号是多少，就可以判断我的进程为什么异常了

我们还可以手动让OS发信号终止进程

衡量一个进程的退出，父进程bash只需要两个数字: 退出码和退出信号

进程等待

进程等待的方法
wait 方法
等待父进程中，任意一个子进程的退出
子进程本身就是软件，父进程本质是在等待某种软件条件就绪

waitpid方法  

pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
当正常返回的时候 waitpid 返回收集到的子进程的进程 ID ；
如果设置了选项 WNOHANG, 而调用中 waitpid 发现没有已退出的子进程可收集 , 则返回 0 ；
如果调用中出错 , 则返回 -1, 这时 errno 会被设置成相应的值以指示错误所在；
参数：
pid：
Pid=-1, 等待任一个子进程。与 wait 等效。
Pid>0. 等待其进程 ID 与 pid 相等的子进程。
status:
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若 WIFEXITED 非零，提取子进程退出码。（查看进程的退出码）
options:
WNOHANG: 若 pid 指定的子进程没有结束，则 waitpid() 函数返回 0 ，不予以等待。若正常结束，则返回该子进程的ID 。
如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退 出信息。
如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
如果不存在该子进程，则立即出错返回。

ptions==0，阻塞等待：子进程没有等到时，会一直堵塞等待

ptions==WNOHANG，非阻塞等待：对子进程进行检测，子进程没退出，直接返回0

所以，ptions==0，返回值只有>0和<0两种情况

ptioons==WNOHANG，返回值有>0和<0和==0三种情况

非阻塞等待的时候+循环=非阻塞轮询

非阻塞等待允许父进程做一些其他事情

获取子进程status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
如果传递NULL，表示不关心子进程的退出状态信息。
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）
0000 0000 0 000 0000
退出状态：[0,255]
终止信号：7位表示够用(0~6)

子进程退出信息：进程退出码+退出信号

这样单独取到 进程退出码和退出信号

利用WIFEXITED(status)和WEXITSTATUS(status)判断和提取退出码

非堵塞等待测试

myprocss.c

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

typedef void(*func_t)();

#define N 3
func_t tasks[N] = {NULL};

void LoadTask()
{
    tasks[0] = PrintLog;
    tasks[1] = Download;
    tasks[2] = MysqlDataSync;
}
void HandlerTask()
{
    for(int i = 0; i < N; i++)
    {
        tasks[i](); // 回调方式
    }
}

// fahter
void DoOtherThing()
{
    HandlerTask();
}


void ChildRun()
{
    //int *p = NULL;
    int cnt = 5;
    while(cnt)
    {
        printf("I am child process, pid: %d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
        sleep(1);
        cnt--;
        //*p = 100;
    }
}

int main()
{
    printf("I am father, pid: %d, ppid:%d\n", getpid(), getppid());

    pid_t id = fork();
    if(id == 0)
    {
        // child
        ChildRun();
        printf("child quit ...\n");
        exit(123);//进程退出码没有返回时，默认为0
    }
    LoadTask();
    // father
    while(1)
    {
        int status = 0;
        pid_t rid = waitpid(id, &status, WNOHANG); // non block
        if(rid == 0)
        {
            usleep(100000);
            printf("child is running, father check next time!\n");
            DoOtherThing();
        }
        else if(rid > 0)
        {
            if(WIFEXITED(status))
            {
                printf("child quit success, child exit code : %d\n", WEXITSTATUS(status));
            }
            else
            {
                printf("child quit unnormal!\n");
            }
            break;
        }
        else
        {
            printf("waitpid failed!\n");
            break;
        }
    }

task.c

#include "task.h"

void PrintLog()
{
    printf("begin PrintLog...\n");
}
void Download()
{
    printf("begin Download...\n");
}
void MysqlDataSync()
{
    printf("begin MySQLDataSync...\n");
}

task.h

#include <stdio.h>

void PrintLog();
void Download();
void MysqlDataSync();

进程程序替换 

替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec*并不创建新进程,所以调用exec前后该进程的id并未改变
进程=内核数据结构+代码和数据
只是进程的程序替换，没有创建新的进程，本质就是被替换进程的程序被加载到内存了

父进程的代码和数据本来是和子进程共享的，但由于进程程序替换，子进程后面替换的程序用的是替换的代码和数据，在物理内存上重新开辟一块空间放置新的代码和数据

替换函数

#include <unistd.h>
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 *path, char *const argv[], char *const envp[]); 为系统接口

path:我们要执行的程序，需要带路径(怎么找到程序)

file：用户可以不传要执行的文件的路径(但文件名要传)

argu：在命令行中怎么执行你就怎么传参 最后一个要传NULL

argu[ ]: 用一个指针数组分别装命令字符串，最后一个空间传NULL，然后传给argu[ ]  

envp[ ]:整体替换所有环境变量，可以自定义环境变量传入

*：

l ：list 列表

v：vector 

p：查找这个程序，系统会自动在环境变量PATH中进行查找

e：环境变量 

 exec*系列的函数执行完毕后，后续的代码不见了，因为被替换了

exec*函数的返回值不用关心，只要替换成功，就不会向后继续运行，只要继续运行了，一定是替换失败

exec*类似Linux上的加载函数

将代码改成多进程版

fork创建子进程，让子进程自己去替换，父进程wait

创建子进程，让子进程完成任务:1.让子进程执行父进程代码的一部分2.让子进程执行一个全新的程序

exec*会将传入的命令行参数或环境变量传给被替换进程的程序

mypragma.cc

#include <iostream>
#include <unistd.h>
using namespace std;


int main(int argc, char *argv[], char *env[])
{
    int i = 0;
    for(; argv[i]; i++)
    {
        printf("argv[%d] : %s\n", i, argv[i]);
    }

    printf("-------------------------------\n");
    for(i=0; env[i]; i++)
    {
        printf("env[%d] : %s\n", i, env[i]);
    }
    printf("-------------------------------\n");

    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;

    return 0;
}

testexec.c

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

int main()
{
    printf("testexec ... begin!\n");
    pid_t id = fork();
    if(id == 0)
    {
      
        char *const argv[] = 
        {
            (char*)"mypragma"     
            NULL
        };
        char *const envp[] =
        {
            (char*)"HAHA=111111",
            (char*)"HEHE=222222",
            NULL
        };
        printf("child pid: %d\n", getpid());
        sleep(2);
        execvpe("./mypragma", argv, envp);
        
        exit(1);
    }

    // fahter
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
    }
    printf("testexec ... end!\n");
    return 0;
}

将父进程bash的环境变量传到被替换进程的程序中然后打印

mypragma.cc


#include <iostream>
#include <unistd.h>
using namespace std;


int main(int argc, char *argv[], char *env[])
{
    int i = 0;
    for(; argv[i]; i++)
    {
        printf("argv[%d] : %s\n", i, argv[i]);
    }

    printf("-------------------------------\n");
    for(i=0; env[i]; i++)
    {
        printf("env[%d] : %s\n", i, env[i]);
    }
    printf("-------------------------------\n");

    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;

    return 0;
}

testexec.c

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

int main()
{
    printf("testexec ... begin!\n");
    pid_t id = fork();
    if(id == 0)
    {
      
        // 我的父进程本身就有一批环境变量！！！, 从bash来
        char *const argv[] = 
        {
            (char*)"mypragma",
            (char*)"-a",
            (char*)"-b",

            NULL
        };
        char *const envp[] =
        {
            (char*)"HAHA=111111",
            (char*)"HEHE=222222",
            NULL
        };
        extern char**environ;
        printf("child pid: %d\n", getpid());
        sleep(2);
        execvpe("./mypragma", argv, environ);
        exit(1);
    }

    // fahter
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
    }
    printf("testexec ... end!\n");
    return 0;
}

替换自己的程序

testexec.c

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

int main()
{
    printf("testexec ... begin!\n");
    pid_t id = fork();
    if(id == 0)
    {
              
        sleep(2);      
        
        execl("./mypragma", "mypragma", NULL);
       
        exit(1);
    }

    // fahter
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
    }
    printf("testexec ... end!\n");
    return 0;
}

替换自己的程序文件，由于我们的文件不在环境变量中，但可根据路径直接写文件名运行

我们还可以将路径写入环境变量或者自己定义环境变量去调用其他类型的替换函数

mypragma.cc

#include <iostream>
#include <unistd.h>
using namespace std;


int main(int argc, char *argv[], char *env[])
{
   
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;
    cout << "hello C++, I am a C++ pragma!: " << getpid() << endl;

    return 0;
}

Makefile

.PHONY:all
all:testexec mypragma

testexec:testexec.c
	gcc -o $@ $^
mypragma:mypragma.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -f testexec mypragma

同时编译两个文件

替换其他程序

test.py

#!/usr/bin/python3


print("hello python")
print("hello python")
print("hello python")
print("hello python")

test.sh

#!/usr/bin/bash


cnt=0
while [ $cnt -le 10 ]
do
    echo "hello shell, cnt: ${cnt}"
    let cnt++
done

testexec.c

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

int main()
{
    printf("testexec ... begin!\n");
    pid_t id = fork();
    if(id == 0)
    {
           
        printf("child pid: %d\n", getpid());
        sleep(2);
      
        
        execl("/usr/bin/python3", "python3", "test.py", NULL);
        //execl("/usr/bin/bash", "bash", "test.sh", NULL);
       
        
        exit(1);
    }

    // fahter
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if(rid > 0)
    {
        printf("father wait success, child exit code: %d\n", WEXITSTATUS(status));
    }
    printf("testexec ... end!\n");
    return 0;
}

这里是替换另一个进程的编译程序，然后再执行对某个文件的编译运行

putenv

系统接口函数

向环境变量表中添加环境变量

简易的shell

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

#define SIZE 512
#define ZERO '\0'
#define SEP " "
#define NUM 32
#define SkipPath(p) do{ p += (strlen(p)-1); while(*p != '/') p--; }while(0)

// 为了方便，我就直接定义了
char cwd[SIZE*2];
char *gArgv[NUM];
int lastcode = 0;

void Die()
{
    exit(1);
}

const char *GetHome()
{
    const char *home = getenv("HOME");
    if(home == NULL) return "/";
    return home;
}

const char *GetUserName()
{
    const char *name = getenv("USER");
    if(name == NULL) return "None";
    return name;
}
const char *GetHostName()
{
    const char *hostname = getenv("HOSTNAME");
    if(hostname == NULL) return "None";
    return hostname;
}
// 临时
const char *GetCwd()
{
    const char *cwd = getenv("PWD");
    if(cwd == NULL) return "None";
    return cwd;
}

// commandline : output
void MakeCommandLineAndPrint()
{
    char line[SIZE];
    const char *username = GetUserName();
    const char *hostname = GetHostName();
    const char *cwd = GetCwd();

    SkipPath(cwd);
    snprintf(line, sizeof(line), "[%s@%s %s]> ", username, hostname, strlen(cwd) == 1 ? "/" : cwd+1);
    printf("%s", line);
    fflush(stdout);
}

int GetUserCommand(char command[], size_t n)
{
    char *s = fgets(command, n, stdin);
    if(s == NULL) return -1;
    command[strlen(command)-1] = ZERO;
    return strlen(command); 
}


void SplitCommand(char command[], size_t n)
{
    (void)n;
    // "ls -a -l -n" -> "ls" "-a" "-l" "-n"
    gArgv[0] = strtok(command, SEP);
    int index = 1;
    while((gArgv[index++] = strtok(NULL, SEP))); // done, 故意写成=,表示先赋值，在判断. 分割之后，strtok会返回NULL，刚好让gArgv最后一个元素是NULL, 并且while判断结束
}

void ExecuteCommand()
{
    pid_t id = fork();
    if(id < 0) Die();
    else if(id == 0)
    {
        // child
        execvp(gArgv[0], gArgv);
        exit(errno);
    }
    else
    {
        // fahter
        int status = 0;
        pid_t rid = waitpid(id, &status, 0);
        if(rid > 0)
        {
            lastcode = WEXITSTATUS(status);
            if(lastcode != 0) printf("%s:%s:%d\n", gArgv[0], strerror(lastcode), lastcode);
        }
    }
}

void Cd()
{
    const char *path = gArgv[1];
    if(path == NULL) path = GetHome();
    // path 一定存在
    chdir(path);//改变当前路径，系统接口

    // 刷新环境变量
    char temp[SIZE*2];
    getcwd(temp, sizeof(temp));//获取当前的绝对路径，系统接口
    snprintf(cwd, sizeof(cwd), "PWD=%s", temp);
    putenv(cwd); // OK     //写入环境变量，系统接口
}

int CheckBuildin()
{
    int yes = 0;
    const char *enter_cmd = gArgv[0];
    if(strcmp(enter_cmd, "cd") == 0)
    {
        yes = 1;
        Cd();
    }
    else if(strcmp(enter_cmd, "echo") == 0 && strcmp(gArgv[1], "$?") == 0)
    {
        yes = 1;
        printf("%d\n", lastcode);
        lastcode = 0;
    }
    return yes;
}

int main()
{
    int quit = 0;
    while(!quit)
    {
        // 1. 我们需要自己输出一个命令行
        MakeCommandLineAndPrint();

        // 2. 获取用户命令字符串
        char usercommand[SIZE];
        int n = GetUserCommand(usercommand, sizeof(usercommand));
        if(n <= 0) return 1;

        // 3. 命令行字符串分割. 
        SplitCommand(usercommand, sizeof(usercommand));

        // 4. 检测命令是否是内建命令
        n = CheckBuildin();
        if(n) continue;
        // 5. 执行命令
        ExecuteCommand();
    }
    return 0;
}

cd，echo，export等为内建命令

然后 shell 读取新的一行输入,建立一个新的进程,在这个进程中运行程序 并等待这个进程束。
所以要写一个 shell ，需要循环以下过程 :
1. 获取命令行
2. 解析命令行
3. 建立一个子进程（ fork ）
4. 替换子进程（ execvp ）
5. 父进程等待子进程退出（ wait ）
你好，赵志伟
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
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 1404
操作系统课设：实验二
Linux进程控制详解及实例
09-15
Linux进程控制是操作系统的核心组成部分，它允许用户和系统创建、管理以及终止进程。在这个主题中，我们将深入探讨几个关键的Linux进程控制函数，包括fork()、exec家族、wait()和exit()，并提供实例来解释它们如何...
linux实验四 进程控制实验
02-09
【进程控制实验】是Linux操作系统课程中的一个重要环节，旨在帮助学生深入理解进程的概念以及进程间的交互。通过实验，学生能够掌握以下关键知识点： 1. **进程的概念与程序的区别**： 进程是操作系统资源分配的...
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进程控制
09-14
linux进程控制
LINUX进程控制编程
12-06
本主题“LINUX进程控制编程”旨在深入探讨这些概念，并教你如何在实际编程中应用它们。以下是对这个主题的详细阐述： 一、进程的基本概念 进程是程序在内存中的执行实例，每个进程都有独立的地址空间。在Linux中，...
Linux 进程控制与进程通信1
08-08
（1）Fork的返回值有多种，其用法如下Pid=fork() （5）fork出错可能有两种原因：（1）当前的进程数已经达到了系统规定的上限，这时errno的值被
Linux程序设计上机指导书3：Linux进程控制.pdf
04-04
【Linux进程控制】是Linux程序设计中的核心概念，关乎到系统的多任务运行和资源管理。在Linux中，进程是程序的实例，具有独立的内存空间和执行上下文。本指导书着重于理解和实践Linux进程控制的相关操作。 1. **...
linux进程控制－fork（）.
04-15
### Linux进程控制——fork()详解 #### 一、引言 在Linux系统中，进程是资源分配的基本单位，而线程则是处理器调度的基本单位。进程之间通过特定的方式进行通信和同步，而创建新进程则是实现这些操作的基础。本文...
Linux进程控制编程-获取进程ID实例.pdf
07-11
学习Linux进程控制编程不仅有助于理解系统的运行机制，也对于开发系统级软件、服务器程序和嵌入式系统至关重要。在实际开发中，掌握这些基本的进程控制技术能有效提高程序的稳定性和可维护性。通过阅读书籍如《基于...
Linux进程控制编程-waitpid函数实例.pdf
07-11
总的来说，`waitpid`函数在Linux进程控制编程中扮演着核心角色，它帮助父进程有效地管理子进程的生命周期，确保系统资源的有序回收。通过结合`fork`、`exit`以及`waitpid`等函数，开发者可以实现复杂的进程通信和...
Linux进程控制编程-fork子进程创建实例.pdf
07-11
本文将深入探讨`fork()`函数的工作原理、使用方法及其在Linux进程控制编程中的重要性。 `fork()`函数是C语言标准库中的一个函数，定义在`sys/types.h`和`unistd.h`头文件中。它通过调用内核来创建一个与调用进程...
linux进程控制详解及演示代码
10-14
本文将深入探讨Linux进程控制，包括进程通信、同步与异步的概念，并提供相关的演示代码。 首先，我们来理解什么是进程通信。在多进程环境中，进程间的通信（IPC, Inter-Process Communication）是必不可少的，它...
Linux 进程控制
最新发布
07-01
Linux 进程控制是操作系统管理执行中的程序或线程的一种核心功能。它涉及到创建、调度、同步、通信和终止进程等多个方面。以下是一些关键概念： 1. **进程创建**：在Linux中，可以通过fork()和execve()系统调用来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

你好，赵志伟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值