Linux进程

已于 2024-01-23 16:41:45 修改
阅读量385 收藏 9
点赞数 9
分类专栏： Linux 文章标签： linux
于 2024-01-23 16:08:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57604904/article/details/135757997
版权

目录

一、进程与程序的概念

 二、进程的创建与查看进程信息

 三、进程的退出与回收

 四、守护进程

一、进程与程序的概念

程序
存放在磁盘上的指令和数据的有序集合（文件）
静态的

进程
执行一个程序所分配的资源的总称
动态的

 进程和程序内容区别

BSS段：存放程序中未初始化的全局变量
数据段：已初始化的全局变量
代码段：程序执行代码
堆（heap）：malloc等函数分配内存
栈(stack)：局部变量，函数参数，函数的返回值
进程控制块（pcb)：PID， 进程优先级，文件描述符表

 二、进程的创建与查看进程信息

示例代码：

#include <stdio.h>
#include <unistd.h>
#include<stdlib.h>
int main(int argc,char **argv)
{
	    pid_t pid;
		printf("before fork\n");		
		pid = fork();
		if(pid>0)
		{
			printf("This is father process\n");	
			printf("pid=%d\n",(int)pid);
			printf("father after fork\n");
			while(1)
			{
				sleep(1);	
				printf("father sleep\n");
			}
		}
		else if(pid==0)
		{
			printf("This is child process\n");	
			printf("pid=%d\n",(int)pid);
			printf("child after fork\n");
			while(1)
			{
				sleep(1);	
				printf("child sleep\n");
			}
			
		}
		else if(pid<0)
		{
			perror("fork");	
			exit(0);
		}
		return 0;
}

运行结果：

 运行逻辑：

首先，在父进程中，程序输出 "before fork"，然后调用 fork 函数创建一个子进程。
在 fork 函数之后，父进程和子进程的代码是完全相同的，因为 fork 会复制当前进程的内存空间给子进程。
如果 fork 返回的是正整数，说明当前执行的是父进程。父进程输出 "This is father process" 和父进程的进程ID（pid），然后进入一个无限循环，每秒输出 "father sleep"。
如果 fork 返回的是 0，说明当前执行的是子进程。子进程输出 "This is child process" 和子进程的进程ID（pid），然后进入一个无限循环，每秒输出 "child sleep"。
如果 fork 返回的是负整数，说明 fork 函数调用失败，输出错误信息并退出程序。
由于父进程和子进程是并行运行的，它们的执行顺序可能不确定。在这个例子中，由于父进程和子进程都进入了无限循环，它们会交替执行，但具体哪个进程先运行、哪个先休息会取决于系统的调度策略。

3800的父进程ID（PPID）是2728，而3801的父进程ID（PPID）是3800。

注意：这个打印出的pid=3801,是子进程的pid。

        父进程打印了 "pid=3801"，这是由于 printf("pid=%d\n",(int)pid); 这行代码中的 pid 是通过 fork() 函数返回的，它返回的是子进程的进程ID。所以，在父进程中，这个值是子进程的进程ID。父进程的进程ID是3800，而子进程的进程ID是由操作系统动态分配的。

        输出显示 "pid=3801"，说明此时正在父进程中执行这行代码。在接下来的输出中看到 "This is father process" 和 "father after fork"，这证实了这部分代码是在父进程中执行的。

总结：3801是父进程中 fork() 函数返回的子进程的进程ID，而不是父进程的进程ID。

查看进程信息：

ps     查看系统进程快照
top    查看进程动态信息
/proc  查看进程详细信息

ps 命令详细参数：
-e：显示所有进程
-l：长格式显示更加详细的信息
-f 全部列出，通常和其他选项联用

创建5个子进程：

         如果使用下列代码创建，会出现下图的运行结果，发现不止是父节点在创建子节点，子节点也在创建孙节点............。        

#include <stdio.h>
#include <unistd.h>
#include<stdlib.h>
int main()
{
	    pid_t pid;
		int i;    
		for(i=0;i<5;i++)
		{
			pid = fork();
			if(pid<0)
			{
				perror("fork");
				return 0;	
			}
			else if(pid==0)
			{
				printf("child process\n");
				sleep(5);
			//	break;	
			}
			else
			{
				printf("Father process\n");
				sleep(5);	
			}	
		}
		sleep(100);
}

 如果加入break就能顺利创建：

实现一个进程链，父进程->子进程->孙进程->重孙进程->重重孙进程

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main()
{
    pid_t pid;
    printf("I am A,mypid=%d\n",getpid());
    pid=fork();//创建子进程B
    if(pid==0)
	{
        printf("I am B,mypid=%d\n",getpid());
        pid_t pid1=fork();//创建孙子进程C
        if(pid1==0)
		{
            printf("I am C,mypid=%d\n",getpid());
            pid_t pid2=fork();//创建重孙进程D
            if(pid2==0)
			{
                printf("I am D,mypid=%d\n",getpid());
                pid_t pid3=fork();//创建重重孙进程E
                if(pid3==0)
				{
                    printf("I am E,mypid=%d\n",getpid());
                }
            }
        }
    }
	while(1)
	{
		sleep(1);
	}
return 0;
}

 三、进程的退出与回收

进程的回收：

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
 
int main(int argc, char** argv)
{	 
	   pid_t pid;
	   pid_t rpid;
	   pid = fork();
	   int status;
	   if(pid<0)
	   {
		   perror("fork");
		   return 0;
	   }
	   else if(pid == 0)
	   {
		   sleep(10);
		   printf("child will exit\n");
		   exit(2);
	   }
	   else if(pid >0)
	   {
		   sleep(20);
		   waitpid(-1,&status,WNOHANG);
		   printf("wait..\n");
		   printf("Get child status=%x\n",WEXITSTATUS(status));
	   }
	   while(1)
	   {
		   sleep(1);
	   }
}

linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ vim wait.c
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ gcc -o wait wait.c
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ ./wait
child will exit
wait..
Get child status=2
^C
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ 
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ vim wait.c
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ gcc -o wait wait.c
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ ./wait
child will exit
wait..
Get child status=2
^C
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ cat wait.c
#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
 
int main(int argc, char** argv)
{	 
	   pid_t pid;
	   pid_t rpid;
	   pid = fork();
	   int status;
	   if(pid<0)
	   {
		   perror("fork");
		   return 0;
	   }
	   else if(pid == 0)
	   {
		   sleep(10);
		   printf("child will exit\n");
		   exit(2);
	   }
	   else if(pid >0)
	   {
		   sleep(10);
		   waitpid(-1,&status,0);
		   printf("wait..\n");
		   printf("Get child status=%x\n",WEXITSTATUS(status));
	   }
	   while(1)
	   {
		   sleep(1);
	   }
}
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ 

waitpid 是一个用于等待子进程状态变化的系统调用函数。它的原型如下：
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *status, int options);

pid 参数指定了要等待的子进程的进程ID，可以有以下几种情况：
如果 pid 大于0，则等待进程ID为 pid 的子进程。
如果 pid 等于0，则等待和调用进程属于同一个进程组的任意子进程。
如果 pid 小于-1，则等待进程组ID为 pid 绝对值的任意子进程。
如果 pid 等于-1，则等待任意子进程。

status 参数是一个整数指针，用于存储子进程的退出状态。

options 参数指定一些选项：
0：阻塞等待子进程退出。
WNOHANG：非阻塞，如果没有子进程退出，则立即返回，不等待。
其他选项可以参考 waitpid 函数的文档，例如 WUNTRACED 和 WCONTINUED。
waitpid 函数的返回值是退出的子进程的进程ID，或者出错时返回-1。当使用 WNOHANG 选项时，如果没有子进程退出，返回0。

 进程的退出：

#include  <unistd.h>
 pid_t  fork(void);
创建新的进程，失败时返回-1
成功时父进程返回子进程的进程号，子进程返回0
通过fork的返回值区分父进程和子进程


要点：1 子进程只执行fork之后的代码
2. 父子进程执行顺序是操作系统决定的。

子进程继承了父进程的内容
父子进程有独立的地址空间，互不影响
若父进程先结束
 子进程成为孤儿进程，被init进程收养
 子进程变成后台进程

若子进程先结束
 父进程如果没有及时回收，子进程变成僵尸进程

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

结束当前的进程并将status返回
exit结束进程时会刷新(流)缓冲区

return 和exit的区别
main函数结束时会隐式地调用exit函数，普通函数return是返回上一级。

 查看进程与修改进程优先级：

nice   按用户指定的优先级运行进程
     nice [-n NI值] 命令
NI 范围是 -20~19。数值越大优先级越低
普通用户调整 NI 值的范围是 0~19，而且只能调整自己的进程。
普通用户只能调高 NI 值，而不能降低。如原本 NI 值为 0，则只能调整为大于 0。
只有 root 用户才能设定进程 NI 值为负值，而且可以调整任何用户的进程。
renice   改变正在运行进程的优先级
	renice [优先级] PID

jobs   查看后台进程
bg     将挂起的进程在后台运行
fg      把后台运行的进程放到前台运行

ctrl+z  把运行的前台进程转为后台并停止。
./test &  把test程序后台运行

wait的使用： 

linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ vim execlp.c
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ gcc -o execlp execlp.c
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ ./execlp
father process
hello,world aa bbb
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ cat execlp.c
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{

	pid_t pid;
	pid = fork();
	if(pid == 0)
	{
		execlp("./test","test.c","aa","bbb","./",NULL);
		exit(0);
	}
	else if(pid > 0)
	{
		printf("father process\n");
		wait(NULL);
	}
}
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$ cat test.c
#include<stdio.h>
int main(int argc,char** argv)
{
	printf("hello,world %s %s\n",argv[1],argv[2]);
}
linux@linux:~/code_Linux/code_2024_1_23/Linux_day6$

为什么需要wait?

wait(NULL) 是一个系统调用，用于等待子进程的结束。
它确保父进程在子进程结束之前不会继续执行后续的代码。
如果没有 wait(NULL)，父进程可能在子进程还没有结束时就继续执行，这可能导致意外的行为。

具体来说，wait(NULL) 的作用包括：
阻塞父进程，直到任意一个子进程结束。
获取子进程的终止状态（退出状态），该状态可以通过 WEXITSTATUS 宏来获取。
由于父进程调用了 wait(NULL)，它会等待子进程的结束，并且在子进程结束后获取子进程的退出状态。
这确保了父进程在子进程完全结束之前不会继续执行。

如果不关心子进程的退出状态，也可以使用 waitpid 函数，或者简单地使用 wait(NULL)。
这样可以避免父进程在子进程执行期间继续执行。

用exec函数族函数实现 "ls -l -a" 命令

linux@linux:~/code_Linux/code_2024_1_22$ cd Linux_day5
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ ls
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ vim exec.c
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ gcc -o exec exec.c
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ ./exec
before exec
total 20
drwxrwxr-x 2 linux linux 4096 Jan 22 02:08 .
drwxrwxr-x 4 linux linux 4096 Jan 22 01:57 ..
-rwxrwxr-x 1 linux linux 7366 Jan 22 02:08 exec
-rw-rw-r-- 1 linux linux  183 Jan 22 02:08 exec.c
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ cat exec.c
#include <stdio.h>
#include <unistd.h>
 
int main(){	 
	   printf("before exec\n");
	   if(execl("/bin/ls","ls","-a","-l","./",NULL)<0)
	   {
			 perror("execl");
	   }
		   
		   
}

 四、守护进程

概念：
守护进程又叫精灵进程（Daemon Process），它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。

特点：
始终在后台运行，独立于任何终端，周期性的执行某种任务或等待处理特定事件。
它是个特殊的孤儿进程，这种进程脱离终端，为什么要脱离终端呢？之所以脱离于终端是为了避免进程被任何终端所产生的信息所打断，其在执行过程中的信息也不在任何终端上显示。由于在 Linux 中，每一个系统与用户进行交流的界面称为终端，每一个从此终端开始运行的进程都会依附于这个终端，这个终端就称为这些进程的控制终端，当控制终端被关闭时，相应的进程都会自动关闭。

举例：
http 服务的守护进程叫 httpd，mysql 服务的守护进程叫 mysqld。

更简便地创建守护进程： nohup 命令
nohup  xxxx  &

 守护进程创建步骤：

1.创建子进程fork()
2.退出父进程exit(0)
3.创建新会话setsid(),现在子进程脱离了终端的控制
4.改变工作目录，可以不改，只是更安全，chdir("/");将工作目录变更为根目录
5.开启所有权限umask(0)
6.关闭标准的输入输出与错误文件描述符close()
setsid函数：
pid_t setsid(void);
成功：返回调用进程的会话ID；失败：-1，设置errno。
调用了setsid函数的进程，既是新的会长，也是新的组长

getsid函数
pid_t getsid(pid_t pid)
成功：返回调用进程的会话ID；失败：-1，设置errno
1.pid为0表示察看当前进程session ID
2.ps ajx命令查看系统中的进程。参数a表示不仅列当前用户的进程,也列出所有其他用户的进程,参数x表示不仅列有控制终端的进程,也列出所有无控制终端的进程,参数j表示列出与作业控制相关的信息。
3.组长进程不能成为新会话首进程,新会话首进程必定会成为组长进程。

getpid：pid_t getpid(void);       获取进程id
getpgid：pid_t getpgid(pid_t pid);   获取进程组id



#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
int main(){
  pid_t pid;
  pid = fork();
  if(pid<0){
    perror("fork");
    return 0;
 
  }else if(pid>0){
    exit(0);
  }
  printf("I am a deamon\n");
  printf("sid=%d,pid=%d,pgid=%d\n",getsid(getpid()),getpid(),getpgid(getpid()));
 
  if(setsid()<0){
    perror("setsid");
    exit(0);
  }  
 
  printf("after sid=%d,pid=%d,pgid=%d\n",getsid(getpid()),getpid(),getpgid(getpid()));
   
  chdir("/");
 
  if(umask(0)<0){
    perror("unmask");
    exit(0);
  }
   
  close(0);
  close(1);
  close(2);
  printf("after close \n");  
 
 
 
  sleep(100);
 
}

  列举三个GDB调试多进程程序的命令及其含义：

inferiors：
含义：显示当前正在调试的所有进程的列表。
用法：inferiors 或 info inferiors。
示例：在GDB中输入 inferiors 或 info inferiors 可以查看当前调试的所有进程，以及它们的描述、可执行文件路径等信息。

inferior <n>：
含义：切换到指定的进程，其中 <n> 是目标进程的编号。
用法：inferior <n>。
示例：在GDB中输入 inferior 2 可以切换到编号为2的进程进行调试。

set follow-fork-mode <mode>：
含义：设置在fork系统调用时GDB应该如何继续调试。
用法：set follow-fork-mode <mode>，其中 <mode> 可以是 child、parent 或 ask。
示例：
set follow-fork-mode child：在fork后只跟踪子进程。
set follow-fork-mode parent：在fork后只跟踪父进程。
set follow-fork-mode ask：在fork后询问用户如何继续调试。

使用pthread_create实现 10 个子线程，并且让每个子线程打印自己的线程号

（运行结果：）

linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ vim thread_n.c
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ gcc -o thread_n thread_n.c -lpthread
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ ./thread_n
This is main Thread,tid = 3076303680
This is main Thread,tid = 3067910976
This is main Thread,tid = 3059518272
This is main Thread,tid = 3051125568
This is main Thread,tid = 3042732864
This is main Thread,tid = 3034340160
This is main Thread,tid = 3025947456
This is main Thread,tid = 3017554752
This is main Thread,tid = 3009162048
This is main Thread,tid = 3000769344
arg = 6
This is a Thread test,pid = 8513,tid = 3025947456
arg = 7
This is a Thread test,pid = 8513,tid = 3017554752
arg = 8
This is a Thread test,pid = 8513,tid = 3009162048
arg = 9
This is a Thread test,pid = 8513,tid = 3000769344
arg = 5
This is a Thread test,pid = 8513,tid = 3034340160
arg = 4
This is a Thread test,pid = 8513,tid = 3042732864
arg = 3
This is a Thread test,pid = 8513,tid = 3051125568
arg = 2
This is a Thread test,pid = 8513,tid = 3059518272
arg = 1
This is a Thread test,pid = 8513,tid = 3067910976
arg = 0
This is a Thread test,pid = 8513,tid = 3076303680
^C
linux@linux:~/code_Linux/code_2024_1_22/Linux_day5$ cat thread_n.c

（示例代码：）

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

void* testThread(void* arg)
{

	printf("This is a Thread test,pid = %d,tid = %lu\n",getpid(),(unsigned long int)pthread_self());
	printf("arg = %d\n",(int)arg);
	while(1)	
	{
		sleep(1);
	}
}

int main()
{
	pthread_t tid[10];
	int ret = 0;
	int i = 0;
	for(i = 0;i<10;i++)
	{
		ret = pthread_create(&tid[i],NULL,testThread,(void*)i);
		printf("This is main Thread,tid = %lu\n",(unsigned long int)tid[i]);
	}
	while(1)
	{
		sleep(1);
	}
	return 0;

}

白少平
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux 进程 status,Linux 进程状态详解
weixin_42178963的博客
04-29 3138
目的为了对进程从产生到消亡的整个过程进行跟踪和描述，就需要定义各种进程的各种状态并制定相应的状态转换策略，以此来控制进程的运行。粗略分类运行态：进程占用CPU，并在CPU上运行；就绪态：进程已经具备运行条件，但是CPU还没有分配过来；阻塞态：进程因等待某件事发生而暂时不能运行；当然理论上上述三种状态之间转换分为六种情况；运行 → 就绪：这是有调度引起的，主要是进程占用CPU的时间已耗尽。就绪 → ...
理解Linux进程
03-18
理解Linux进程，文档来自网络，版权归原作者所有。
Linux进程管理
Android系统优化
03-17 3159
Linux是类Unix系统，借鉴了Unix的设计并实现相关接口，但并非Unix。Linux系统中万物皆为文件，这种抽象方便操作数据或设备，只需一套统一的系统接口open, read, write, close即可完成对文件的操作Linux是单内核，支持动态加载内核模块，可在运行时根据需求动态加载和卸载部分内核代码；Linux内核支持可抢占；Linux内核创建进程，采用独特的fork()系统调用，创建进程较高效；
Linux进程状态
qq_51659538的博客
09-09 6125
Linux中的进程状态
linux进程管理
qq_55343342的博客
07-30 2880
linux进程管理
Linux进程状态解析 之 R、S、D、T、Z、X (主要有三个状态)
热门推荐
sdkdlwk的博客
03-25 7万+
转载出处：http://blog.csdn.net/shenwansangz/article/details/51981459 Linux是一个多用户，多任务的系统，可以同时运行多个用户的多个程序，就必然会产生很多的进程，而每个进程会有不同的状态。 Linux进程状态：R (TASK_RUNNING)，可执行状态。 只有在该状态的进程才可能在CPU上
Linux进程状态及优先级
ARMCSKGT的博客
05-06 6005
操作系统想管理好进程并不简单，对于Linux系统将进程分为不同的状态进行管理；例如运行，阻塞，休眠状态等等，每一种状态都有不同的效果，这样才能发挥他的全部功效，且进程之间也有优先级，本文将为您详细讲解！进程状态和进程优先级的知识到这里就介绍的差不多了，通过了解进程状态，知道进程的阻塞和和运行的原理；了解进程优先级，学习了修改进程的优先级影响调度机制，这些知识都在为后面进程控制的学习打下基础！
Linux进程详解
m0_64483960的博客
04-04 5529
一.概述 进程就是系统运行中的程序（process） 是正在执行的一个程序或者命令，每一个进程都是一个运行的实体，都有自己的地址空间，并占用一定的系统资源 例如windows安装程序，先下载程序安装包，安装到指定硬盘。 双击运行后系统就会有对应的应用进程显示。 进程会占用四类资源，CPU，memory，disk，network CPU （Central Processing Unit 中央处理单元 ）lscpu命令可以看到CPU的详细信息 Memory（内存）free -h命令可以查看系统内存
【Linux】Linux进程管理
Linux小白一只~正处于学习阶段，觉得我写的还好的请多多给我点赞呀,谢谢大家！！(๑＞ڡ＜)☆
08-07 4067
Linux进程管理
Linux进程管理命令
slgcsdn的博客
05-24 2637
1.ps命令 ps aux：查看系统中的所有进程，使用BS操作系统格式 ps -le：查看系统中的所有进程，使用LINUX标准命令格式 选项：a：显示一个终端的所有进程，除会话引线外； u：显示进程的归属用户及内存的使用情况； x：显示没有控制终端的进程； -l：长格式显示更加详细的信息； -e：显示所有进程； 常用的命令：ps aux：可以查看系统中所有的进程 ps -le：可以查看系统中所有的进程，而且还能看到进程额父进程的PID和进程优先级； ps -l：只能看到当前shell产生的进程； 僵尸进程
Linux 进程调度策略
小羊苏C的博客
03-16 2977
进程分类 有两种传统的分类法： 方法一 CPU密集 I/O密集 方法二 交互 （比如记事本） 批处理 （比如后台、编译器进程） 实时 进程抢占 进程是可抢占的，在新的进程进入TASK_RUNNING状态，表示可以运行的时候，内核会检查他们的动态优先级。如果比当前的进程优先级高就调用调度器进行调度。 调度算法和调度类 SCHED_FIFO 一个先入先出的实时过程。当调度器将CPU分配给进程时，它会将进程描述符保留在运行队列列表中的当前位置。如果没有其他更高优先级的实时进程可以运行，那
linux进程管理原理
02-24
linux计算需求的表现是以进程的通用抽象为中心的。进程可以是短期的（从命令行执行的一个命令），也可以是长期的（一种网络服务）。因此，对进程及其调度进行一般管理就显得极为重要。在用户空间，进程是由进程...
Linux进程的睡眠和唤醒
07-14
1 Linux进程的睡眠和唤醒 在Linux中，仅等待CPU时间的进程称为就绪进程，它们被放置在一个运行队列中，一个就绪进程的状 态标志位为TASK_RUNNING。一旦一个运行中的进程时间片用完， Linux 内核的调度器会剥夺这个...
实验 Linux进程通信的参考答案
07-05
实验 Linux 进程通信的参考答案 Linux 进程通信是指在操作系统中，多个进程之间进行数据交换和同步的机制。在 Linux 中，进程通信可以通过信号、管道和共享内存等方式实现。 一、信号机制 在 Linux 中，信号是一...
Linux 进程相关命令
01-09
在Linux系统中，有 5 种常见的进程状态，分别为运行、中断、不可中断、僵死与停止，其各自含义如下所示。 **R（运行）：**进程正在运行或在运行队列中等待。 **S（中断）：**进程处于休眠中，当某个条件形
Linux进程调度
01-09
Linux进程调度 1.Linux进程类型 普通进程： 采用动态优先级来调度； 调度程序周期性地修改优先级 实时进程： 采用静态优先级来调度； 由用户预先指定，以后不会改变 2.Linux进程优先级 静态优先级： 进程创建时指定...
Linux 进程管理四个命令详解.docx
11-09
Linux 进程管理四个命令详解 Linux 进程管理是 Linux 操作系统中一个非常重要的组件，它负责管理和控制系统中的进程。Linux 提供了多种命令来管理和监控进程，这些命令可以帮助系统管理员和开发者更好地了解和控制...
linux进程操作
07-27
linux进程控制， 入门操作
linux 进程
08-01
进程间通讯的特点综述的优点和缺点的分析LINUX 操作系统
Linux进程优先级
最新发布
04-09
Linux进程优先级是指CPU资源分配的先后顺序，即进程的优先权。优先级高的进程有优先执行的权利，可以改善系统性能。Linux提供了修改进程优先级的权限，让我们可以对多任务运行进行合理处理，提高系统运行效率[^1]。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值