Linux进程控制

已于 2024-04-16 19:11:25 修改
阅读量46 收藏
点赞数 1
分类专栏： Linux系统 文章标签： linux 服务器 运维
于 2023-10-30 18:32:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65558082/article/details/133976415
版权

目录

1. 进程的创建

1.1 fork函数初识

在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include <unistd.h>

pid_t id = fork(void);
//返回值: 子进程中返回0，父进程返回子进程id，出错返回-1

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

  • 分配新的内存块和内核数据结构给子进程
  • 将父进程部分数据结构内容拷贝至子进程
  • 添加子进程到系统进程列表当中
  • fork返回，开始调度器调度


当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程，看如下程序。

int main(void)
{
	pid_t pid;
	printf("Before: pid is %d\n", getpid());

	if ((pid = fork()) == -1)
	{
		perror("fork()"); 
		exit(1);
	}

	printf("After:pid is %d, fork return %d\n", getpid(), pid);
	sleep(1);

	return 0;
}

运行结果：

这里看到了三行输出，一行before，两行after。进程13773先打印before消息，然后它有打印after。另一个after消息由13774打印的。注意到进程13774没有打印before，为什么呢？如下图所示：

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，fork之后，谁先执行完全由调度器决定的！

因为fork之前只有父进程，fork之后有两个进程！那么fork之后是否只有fork之后的代码是被父子进程共享的？？

我们知道进程具有独立性：代码和数据必须是独立的！我们针对数据给了写时拷贝的方案，代码是只读的，所以只能共享。一般情况，fork之后父子共享所有的代码！！

子进程执行的后续代码 != 共享的所有代码，只不过子进程只能从这里开始执行！！为什么？

CPU有一个寄存器叫eip：程序计数器，保存当前正在执行指令的下一条指令！在某些教材也叫pc指针。eip程序计数器会拷贝给子进程，子进程便从该eip所指向的代码出开始执行。

但是不代表子进程不能从头开始，子进程可以修改eip的值从main函数开始，就能从头开始执行代码！

1.2 fork函数的返回值

  • 子进程返回0，
  • 父进程返回的是子进程的pid。

1.3 fork之后OS做了什么？

进程 = 内核的进程数据结构 + 进程的代码和数据

通过创建子进程的内核数据结构(struct task_struct + struct mm_struct + 页表) + 继承父进程的代码，数据以写时拷贝的方式，来进程共享或者独立。

1.4 写时拷贝

通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自拥有一份数据。具体见下图：

父进程创建子进程之后，父子都有虚拟地址空间和页表，只不过子进程的各种隐射关系全部继承自父进程，所以父子的代码是共享的！

但是页表里面还会包含读写属性的设置，写时拷贝的底层实现其实就是在创建子进程之后，把父子进程的页表隐射关系全部设置为只读的。

当你写入时(当然也会判断写入的内存区域是代码还是数据)。比如说子进程想写入一份数据，父进程没有写入，所以父进程不管，依旧指向自己的代码和数据。而子进程代码是共享的，所以和父进程指向的代码区域是一样的！因为子进程想写入数据，所以操作系统会把数据拷贝到另一个区域，在此区域修改！之后页表数据的只读属性被去掉了变成了正常属性，最后操作系统再重新修复父子进程页表的映射关系！

1.5 fork常规用法和调用失败的原因

用法：

  • 一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
  • 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

失败的原因：

  • 系统中有太多的进程
  • 实际用户的进程数超过了限制

2. 进程终止

2.1 关于终止的认识

C/C++的时候，main是程序的入口函数，且通常最后我们都要写一句return 0

  1. return 0，给谁return？
  2. 为什么是0？其他值可以吗？

常见进程退出：

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

所以进程代码跑完，结果是否正确：
0：表示success，非0：表示失败。可是我们最想知道的其实是失败的原因！所以：非0标识不同的原因！return x其实是进程退出码！表示进程退出的信息，让父进程读取的，以便对处于僵尸态的子进程进行处理！

查看最近一条的退出码指令：

echo $?

这条命令表示在bash中最近一次执行完毕时对应进程的退出码！
假设我们自己的程序里返回123，第一次就是123，第二次是0的原因是echo本身这个程序执行成功了！所以echo其实也是一个可执行程序。

2.2 进程常见退出方法

2.2.1 退出方式

正常终止：

  1. 在main函数中return
  2. 在自己的任意代码任意地点中，调用exit()，括号里的就是退出码。
  3. _exit()，它和exit()很像，其实就是exit()调用了_exit()。

异常退出：

  • ctrl + c，信号终止

2.2.2 _exit函数

#include <unistd.h>
void _exit(int status);
//参数：status 定义了进程的终止状态，父进程通过wait来获取该值
  • 说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。

2.2.3 exit函数

#include <unistd.h>
void exit(int status);

exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：

  1. 执行用户通过 atexit或on_exit定义的清理函数。
  2. 关闭所有打开的流，所有的缓存数据均被写入
  3. 调用_exit

2.2.4 exit和_exit的区别

exit：一秒之后数据就被刷新出来了，因为我们打印的时候没有加\n，数据还在缓冲区。程序退出后数据才被刷新出来。
_exit：我们唯一做的就是把exit换成_exit.我们发现程序退出数据并没有被刷新出来。

结论：
exit终止进程，刷新缓冲区
_exit直接终止进程，不会有任何刷新操作

2.2.5 return退出

return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。

3. 进程等待

3.1 进程等待的必要性

  • 我们知道，在子进程退出的时候，父进程如果不管不顾，就可能造成僵尸进程的问题，进而造成内存泄漏。
  • 另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill - 9也无能为力，因为谁也没有办法杀死一个已经死去的进程。
  • 最后，父进程派给子进程的任务完成的如何，我们需要知道。例如：子进程运行完成，结果对还是不对，或者是否正常退出。
  • 父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

3.2 进程等待的方法

3.2.1 wait方法

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

pid_t wait(int* status);

返回值：
成功返回被等待进程pid，失败返回-1。

参数：
输出型参数，获取子进程退出状态, 不关心则可以设置成为NULL

3.2.2 waitpid方法

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

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。
  • 0：阻塞等待

int* status是一个输出型参数，wait/waitpid()是系统调用，通过调用该函数从函数内部拿出特定的数据，这里的内部是指从task_struct中拿出子进程退出的退出码。

注意：

  1. 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
  2. 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
  3. 如果不存在该子进程，则立即出错返回。

3.3 获取子进程的status

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


我们通过这个整数的次低8位就能拿到子进程的退出码。1-7比特位可以拿到程序异常退出的终止信号。

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

int main() 
{
	pid_t pid;

	if ((pid = fork()) == -1)
		perror("fork"), exit(1);

	if (pid == 0) 
	{
		sleep(20);
		exit(10);
	}
	else 
	{
		int st;
		int ret = wait(&st);

		if (ret > 0 && (st & 0X7F) == 0) // 正常退出
		{ 
			printf("child exit code:%d\n", (st >> 8) & 0XFF);
		}
		else if (ret > 0) // 异常退出
		{  
			printf("sig code : %d\n", st & 0X7F);
		}
	}

	return 0;
}

运行结果：


查看退出码也可以这样写：

if(WIFEXITEL(status))
{
    printf("子进程是正常退出的，退出码:%d\n",WEXITSTATUS(status));
}

3.4 代码实现

  • 进程的阻塞等待方式：
int main()
{
	pid_t pid;
	pid = fork();
	if (pid < 0) 
	{
		printf("%s fork error\n", __FUNCTION__);
		return 1;
	}
	else if (pid == 0) 
	{ //child
		printf("child is run, pid is : %d\n", getpid());
		sleep(5);
		exit(257);
	}
	else 
	{
		int status = 0;
		pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S
		printf("this is test for wait\n");

		if (WIFEXITED(status) && ret == pid) 
		{
			printf("wait child 5s success, child return code is :%d.\n", WEXITSTATUS(status));
		}
		else 
		{
			printf("wait child failed, return.\n");
			return 1;
		}
	}

	return 0;
}

运行结果：

  • 进程的非阻塞等待方式：
int main()
{
	pid_t pid;
	pid = fork();
	if (pid < 0) 
	{
		printf("%s fork error\n", __FUNCTION__);
		return 1;
	}
	else if (pid == 0) 
	{ //child
		printf("child is run, pid is : %d\n", getpid());
		sleep(5);
		exit(1);
	}
	else 
	{
		int status = 0;
		pid_t ret = 0;
		do
		{
			ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
			if (ret == 0) 
			{
				printf("child is running\n");
			}
			sleep(1);
		}while(ret == 0);

		if (WIFEXITED(status) && ret == pid) 
		{
			printf("wait child 5s success, child return code is :%d.\n", WEXITSTATUS(status));
		}
		else 
		{
			printf("wait child failed, return.\n");
			return 1;
		}
	}

	return 0;
}

运行结果：


问题1：为什么不能定义一个全局变量code，子进程退出的时候就把code设置好特定的值，然后父进程回收的时候直接拿code的数据呢？

答：绝对不可以，因为会发生写时拷贝。

问题2：一个子进程既有退出码:0，又有退出信号：11。应该先看谁？

答：常见进程退出：

  • 代码跑完，结果正确
  • 代码跑完，结果不正确
  • 代码没跑完，程序异常了

退出码对应的是前两种情况，退出信号是第3种情况！
程序正常跑完，只关心退出码。一旦进程出现异常，只关心退出信号，退出码没有任何意义！

4. 进程程序替换

4.1 替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动
例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

4.2 替换函数

有六种以exec开头的函数,统称exec函数:

 #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 execve(const char *path, char *const argv[], char *const envp[]);

六种函数解释：

  • 这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。
  • 如果调用出错则返回-1
  • 所以exec函数只有出错的返回值而没有成功的返回值。

命名理解：
这些函数原型看起来很容易混,但只要掌握了规律就很好记住。

  • l(list) : 表示参数采用列表
  • v(vector) : 参数用数组
  • p(path) : 有p自动搜索环境变量PATH
  • e(env) : 表示自己维护环境变量
函数名参数格式是否带路径是否使用当前环境变量
execl列表不是是
execlp列表是是
execle列表不是不是，需要自己组装环境变量
execv数组不是是
execvp数组是是
execve数组不是不是，需要自己组装环境变量

exec调用举例如下：

#include <unistd.h>

int main()
{
	char* const argv[] = { "ps", "-ef", NULL };
	char* const envp[] = { "PATH=/bin:/usr/bin", "TERM=console", NULL };
	execl("/bin/ps", "ps", "-ef", NULL);

	// 带p的，可以使用环境变量PATH，无需写全路径
	execlp("ps", "ps", "-ef", NULL);

	// 带e的，需要自己组装环境变量
	execle("ps", "ps", "-ef", NULL, envp);

	execv("/bin/ps", argv);
	
	// 带p的，可以使用环境变量PATH，无需写全路径
	execvp("ps", argv);

	// 带e的，需要自己组装环境变量
	execve("/bin/ps", argv, envp);

	exit(0);
}

事实上，只有execve是真正的系统调用，其它五个函数最终都调用 execve，所以execve在man手册 第2节,其它函数在man手册第3节。这些函数之间的关系如下图所示：

4.3 自己做一个简易的shell

考虑下面这个与shell典型的互动：

[root@localhost epoll]# ls
 client.cpp  readme.md  server.cpp  utility.h
[root@localhost epoll]# ps
 PID TTY          TIME CMD
 3451 pts/0    00:00:00 bash
 3514 pts/0    00:00:00 ps

如下图的时间轴用来表示事件的发生次序。其中时间从左向右。shell由标识为sh的方块代表，它随着时间的流逝从左向右移动。shell从用户读入字符串"ls"。shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。

然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序，并等待这个进程结束。 所以要写一个shell，需要循环以下过程：

  1. 获取命令行
  2. 解析命令行
  3. 建立一个子进程（fork）
  4. 替换子进程（execvp）
  5. 父进程等待子进程退出（wait）

根据这些思路，就可以自己来实现一个shell了。

代码实现：

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

#define right "]"
#define left "["
#define LABLE "$"
#define DELIM " \t"
#define LINE_SIZE 1024
#define ARGC_SIZE 32
#define EXIT_CODE 44

int lastcode = 0;
char** environ;
char commandline[LINE_SIZE];
char* argv[ARGC_SIZE];
char pwd[LINE_SIZE];

//自定义环境变量表
char myenv[LINE_SIZE];

const char* getusername()   //获取用户名
{
    return getenv("USER");
}

const char* gethostname()   //获取显示或设置系统的主机名称
{
    return getenv("HOSTNAME");
}

void getpwd()
{
    getcwd(pwd, sizeof(pwd));   //getcwd会将当前工作目录的绝对路径复制到参数pwd所指的内存空间中
}

void interact(char *cline, int size)   //交互界面
{
    getpwd();
    printf(left"%s@%s %s"right""LABLE" ", getusername(), gethostname(), pwd);
    char* s = fgets(cline, size, stdin);
    assert(s);
    (void)s;
    cline[strlen(cline) - 1] = '\0';
}

int splitstring(char cline[], char *_argv[])   //字符串分割
{
    int i = 0;
    argv[i++] = strtok(cline, DELIM);  //strtok函数是将字符串分解。第一个参数是为要分解的字符串，后面的是分隔符字符。
									   //取第一个片段调用时，第一个参数指向要分解的字符串，之后再次调用要把第一个参数设成NULL。
    while(_argv[i++] = strtok(NULL, DELIM)); 
    return i - 1;
}

void NormalExcute(char *_argv[])   //指令的执行
{
    pid_t id = fork();
    if(id < 0)
    {
        perror("fork");
    }
    else if(id == 0)   //子进程
    {
        execvp(_argv[0], _argv);   //进程替换
        exit(EXIT_CODE);
    }
    else   //父进程
    {
        int status = 0;
        int rid = waitpid(id, &status, 0);  //进程等待
        if(rid == id)
        {
            lastcode = WEXITSTATUS(status);
        }
    }
}

int buildCommand(char* _argv[], int _argc)  //内建命令的判断和执行
{
   if(_argc == 2 && strcmp(_argv[0], "cd") == 0)
   {
        chdir(_argv[1]);  //chdir函数相当于cd命令
        getpwd();         //获取当前路径
        sprintf(getenv("PWD"), "%s", pwd);
        return 1;
   }
   else if(_argc == 2 && strcmp(_argv[0], "export") == 0)
   {
        strcpy(myenv, _argv[1]);  //将自定义的环境变量保存到
        putenv(myenv);   //改变或增加环境变量的内容
        return 1;
   }
   else if(_argc == 2 && strcmp(_argv[0], "echo") == 0)
   {
        if(strcmp(_argv[1], "$?") == 0)   //获取最近进程结束时的退出码
        {
            printf("%d\n", lastcode);
            lastcode = 0;
        }
        else if(*_argv[1] == '$')
        {
            char* val = getenv(_argv[1] + 1);   //从环境中获取字符串,从而获取环境变量的值
            if(val)
            {
                printf("%s\n", val);
            }
        }
        else 
        {
            printf("%s\n", _argv[1]);
        }

        return 1;
   }

   if(strcmp(_argv[0], "ls") == 0)
   {
        _argv[_argc++] = "--color";   //解决ls颜色的问题
        _argv[_argc] = nullptr;
   }
   
   return 0;
}

int main()
{
    while(1)
    {
        // 1. 交互问题,获取命令行
        interact(commandline, sizeof(commandline));
        
        // 2.子串分割，获取命令行
        int argc = splitstring(commandline, argv);
        if(argc == 0)
        {
            continue;
        }
        
        // 3.指令的判断，即内建命令的执行
        int n = buildCommand(argv, argc);


        // 4.普通命令的执行
        if(!n)
        {
            NormalExcute(argv);
        }

    }

    return 0;
}

4.4 函数和进程之间的相似性

exec/exit就像call/return
一个C/C++程序有很多函数组成。一个函数可以调用另外一个函数，同时传递给它一些参数。被调用的函数执行一定的操作，然后返回一个值。每个函数都有他的局部变量，不同的函数通过call/return系统进行通信。 这种通过参数和返回值在拥有私有数据的函数间通信的模式是结构化程序设计的基础。Linux鼓励将这种应用于程序之内的模式扩展到程序之间。如下图：

一个C/C++程序可以fork/exec另一个程序，并传给它一些参数。这个被调用的程序执行一定的操作，然后通过exit(n)来返回值。调用它的进程可以通过wait（&ret）来获取exit的返回值。

Smile丶凉轩
关注
专栏目录
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 1528
操作系统课设：实验二
Linux进程控制实验
qq_43796170的博客
11-22 4441
实验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 2164
实验三 Linux进程的创建与控制一、实验目的(1)加深对进程概念的理解，明确进程和程序的区别。(2)进一步认识并发执行的实质。(3)分析进程竞争资源现象，学习解决进程互斥的方法。(4)了解Linux系统中进程通信的基本原理。二、实验预备内容阅读Linux的fork.c源文件，分析进程的创建过程。三、实验内容1. 进程的家族关系在主程序中用3个fork()调用，最后输出一个字符或字符串，运行此简单...
linux进程控制实验心得,Linux学习心得12-进程管理
weixin_31971181的博客
04-28 2398
Linux操作系统包括三种不同类型的进程，每种进程都有自己的特点和属性：交互进程:由shell启动的进程。批处理进程:这种进程和终端没有联系，是一个进程序列。守护进程:在后台持续运行的进程。前台启动:一般地，用户键入一个命令，就已经启动了一个前台的进程。后台启动 :对于非常耗时进程，可以然进程在后台运行。从后台启动进程其实就是在命令结尾加上一个“&”号每个进程，都会对应一个父进程，而这个父...
深剖 Linux 进程控制
qq_61500888的博客
08-19 6674
带你一命通关 Linux 进程控制 十五分钟手撕进程控制原理
实验五 linux进程控制,实验五 Linux进程管理和打印管理
weixin_28904055的博客
05-01 1832
实验五 Linux进程管理和打印管理实验五 Linux进程管理和打印管理一. 一. 实验目的：1． 1． 进行系统进程管理。2． 2． 配置Linux下的打印服务器，实现局域网内的Linux和Windows客户端共享使用服务器的打印机。二. 二. 实验内容：1． 1． 进程状态查看；2． 2． 控制系统中运行的进程；3． 3． 安排一次性和周期性自动执行的后台进程；4． 4...
实验四 linux进程控制实验报告,Linux系统进程控制操作系统实验报告4
weixin_42500369的博客
05-02 1517
实验课程名称：操作系统实验项目名称Linux系统进程控制实验成绩实验者专业班级组别同组者实验日期年月日第一部分：实验分析与设计(可加页)实验内容描述(问题域描述)要求：掌握Linux系统中进程控制原语fork( )、sleep( )、wait( )、exit( )、exec的使用方法。内容：在Linux系统中编写C程序，创建一个子进程。父进程和子进程交替运行。父进程先显示一次“Current ti...
Linux进程控制（详解）
梅山
03-26 5004
内容来自：爱编程的大丙 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。...
【2024版】最新kali linux入门及常用简单工具介绍（非常详细）零基础入门到精通，收藏这一篇就够了_kalilinux
weixin_57514792的博客
10-07 1264
最新kali linux入门及常用简单工具介绍
《Linux从小白到高手》综合应用篇：详解Linux系统调优之内存优化
最新发布
qq_45732829的博客
10-11 679
内存是影响Linux性能的主要因素之一，内存资源的充足与否直接影响应用系统的使用性能。内存调优的主要目标是合理分配和利用内存资源，减少内存浪费，提高内存利用率，从而提升系统整体性能。
linux之curl
qq_41081716的博客
10-06 443
发送指定的数据作为POST请求的主体。数据可以是键值对的形式。： 添加自定义HTTP头部。可以多次使用以添加多个头部。： 用于发送表单数据，特别是文件上传。： 指定请求方法，例如。
Linux下Qt项目出现libQt5WebEngineCore.so报错
weixin_74239923的博客
10-08 175
总的来说，这条命令的目的是将ld.gold链接器设置为系统默认的链接器，通过替换/usr/bin/ld来实现。
Linux——定时任务调度
什么时候才不是菜鸟....
10-08 363
定时任务调度
Linux 进程控制
07-01
Linux 进程控制是操作系统管理执行中的程序或线程的一种核心功能。它涉及到创建、调度、同步、通信和终止进程等多个方面。以下是一些关键概念： 1. **进程创建**：在Linux中，可以通过fork()和execve()系统调用来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值