Linux系统编程——进程控制

最新推荐文章于 2024-03-02 18:37:09 发布
最新推荐文章于 2024-03-02 18:37:09 发布
阅读量295 收藏 2
点赞数 1
文章标签： python linux java 操作系统 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21685903/article/details/108676106
版权

在学习Linux系统编程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

09-linux-day05(进程控制)

目录：一、学习目标二、进程1、进程和程序2、单道和多道程序设计3、进程的状态转化4、MMU 的作用5、PCB的概念6、获取环境变量7、进程控制函数fork8、fork创建子进程9、进程控制的命令10、创建n个子进程11、循环创建n个子进程控制顺序12、父子进程共享的内容13、父子进程不共享全局变量14、execlp函数介绍15、exec函数规律16、exel实现自定义程序17、孤儿进程与僵尸进程18、wait函数简单使用和说明19、wait回收并且查看死亡原因20、waitpid回收子进程21、用wait回收多个子进程22、waitpid回收多个子进程

一、学习目标

1、了解进程相关的概念

2、掌握fork/getpid/getppid函数的使用

3、熟练掌握ps/kill命令的使用

4、熟练掌握execl/execlp函数的使用

5、说出什么是孤儿进程什么是僵尸进程

6、熟练掌握wait函数的使用

7、熟练掌握waitpid函数的使用

二、进程

1、进程和程序

什么是程序？编译好的二进制文件。

什么是进程？运行着的程序。

　　站在程序员的角度：运行一系列指令的过程。

　　站在操作系统角度：分配系统资源的基本单位。

区别：

　　程序占用磁盘，不占用系统资源。

　　进程占用系统资源。

　　一个程序对应多个进程，一个进程对应一个程序。

 　　程序没有生命周期，进程有生命周期。

2、单道和多道程序设计

3、进程的状态转化

进程的状态切换

4、MMU 的作用

》MMU作用：1)虚拟内存和物理内存的映射；2)修改内存访问级别

用户空间映射到物理内存是独立的。

5、PCB的概念

Linux内核的进程控制块是task_struct结构体。

查找结构体：

> sudo grep -rn "struct task_struct {" /usr/

技巧：光标停留在{上，按%，可以到结构体的结尾。(400多行)

查看进程的资源上限：

>ulimit -a

6、获取环境变量

查看所有的环境变量：(写法：key=value，且等号两端不能有空格)

>env

常见的环境变量：

>echo $HOME

>echo $PATH

》getenv函数——获取环境变量

man 2 getenv

char *getenv(const char *name);

>touch getenv.c

>vi getenv.c

1 #include<stdio.h>
2 #include<stdlib.h>
3 
4 int main()
5 {
6     printf("homepath is [%s]\n", getenv("HOME"));
7     return 0;
8 }

>make

>./getenv

》setenv函数——设置环境变量的值

man 2 setenv

int setenv(const char *name, const char *value, int overwrite);

　　参数overwrite取值：1-覆盖原环境变量；0-不覆盖(该参数常用于设置新环境变量。)

一般配置(.bashrc)文件!(如：export key=val;)

》unsetenv函数——删除环境变量name的定义

man 2 unsetenv

int unsetenv(const char *name);

　　注意事项：name不存在仍返回0(成功)，当name命名为“ABC=”时则会出错!

7、进程控制函数fork

>touch fork.c

>vi fork.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 
 4 int main()
 5 {
 6     printf("Begin ....\n");//此处缺少“\n”结果会不一样，这是由于printf有缓冲区机制，往屏幕上输出，会有行缓冲
 7     pid_t pid = fork();
 8     printf("End ....\n");
 9     return 0;
10 }

>make

>./fork

(可以知道结束了两个进程。)

》getpid获得当前进程的PID和进程ID，，getppid——获得当前进程父进程的ID

man getpid

pid_t getpid(void);

pid_t getppid(void);

8、fork创建子进程

>vi fork.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<stdlib.h>
 4 
 5 int main()
 6 {
 7     printf("Begin ....\n");
 8     pid_t pid = fork();
 9     if(pid < 0){
10         perror("fork err");
11         exit(1);
12     }
13     if(pid == 0){
14         //子进程
15         printf("I am a child,pid = %d,ppid = %d\n",getpid(), getppid());
16     }
17     else if(pid > 0){
18         //父进程的逻辑
19         printf("childpid=%d,self=%d,ppid=%d\n",pid,getpid(),getppid());
20         sleep(1);//让父进程等待一段时间，再死去。
21     }
22     
23     printf("End ....\n");
24     return 0;
25 }

>make

>./fork

9、进程控制的命令

>vi fork.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<stdlib.h>
 4 
 5 int main()
 6 {
 7     printf("Begin ....\n");
 8     pid_t pid = fork();
 9     if(pid < 0){
10         perror("fork err");
11         exit(1);
12     }
13     if(pid == 0){
14         //子进程
15         printf("I am a child,pid = %d,ppid = %d\n",getpid(), getppid());
16         while(1){
17             printf("I am a child\n");
18             sleep(1);
19         }
20     }
21     else if(pid > 0){
22         //父进程的逻辑
23         printf("childpid=%d,self=%d,ppid=%d\n",pid,getpid(),getppid());
24         while(1){
25             sleep(1);
26         }
27     }
28     
29     printf("End ....\n");
30     return 0;
31 }

>make

>./fork

让子进程一直保持运行，打开另一个终端查看PPID和PID分析：

》ps aux——查看进程相关信息的指令

》ps ajx——可以查看更多进程相关的信息，从而追溯进程之间的血缘关系

可以看到PPID、PID，可以看出shell进程是所有进程的父亲，继续追溯，可以看到最终父进程是init

(init进程是所有进程的祖先！)

>kill -9 2890

>ps ajx

杀死了父进程，init成为子进程2891新的父亲。

>kill 2891

杀死子进程

》kill指令——给进程发送一个信号

　　kill -l 查看信号相关的信息

　　SIGKILL 9号信号

　　kill -9 pid——杀死进程

10、创建n个子进程

需求：让父进程创建n个子进程

>touch nfork.c

>vi nfork.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<stdlib.h>
 4 
 5 int main()
 6 {
 7     int n = 5;
 8     int i = 0;
 9     pid_t pid = 0;
10     for(i = 0; i < 5; i++){//父进程循环结束
11         pid = fork();
12         if(pid == 0){
13             //son
14             printf("I am child, pid=%d,ppid=%d\n",getpid(),getppid());
15             //break;//子进程退出循环的接口
16         }
17         else if(pid > 0){
18             //father
19             printf("I am father, pid=%d,ppid=%d\n",getpid(),getppid());
20         }
21     }
22     while(1){
23         sleep(1);
24     }
25     return 0;
26 }

>gcc nfork.c

>./a.out

>ps aux | grep a.out |grep -v grep | wc -l

(创建了32个进程！)

11、循环创建n个子进程控制顺序

》需求：精确控制各个子进程

>touch nfork1.c

>vi nfork1.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<stdlib.h>
 4 
 5 int main()
 6 {
 7     int n = 5;
 8     int i = 0;
 9     pid_t pid = 0;
10     for(i = 0; i < 5; i++){//父进程循环结束
11         pid = fork();
12         if(pid == 0){
13             //son
14             printf("I am child, pid=%d,ppid=%d\n",getpid(),getppid());
15             break;//子进程退出循环的接口
16         }
17         else if(pid > 0){
18             //father
19             //printf("I am father, pid=%d,ppid=%d\n",getpid(),getppid());
20         }
21     }
22     
23     sleep(i);
24     if(i < 5){
25         printf("I am child, will exit,pid=%d,ppid=%d\n",getpid(),getppid());
26     }
27     else{
28         //father
29         printf("I am parent, will out,pid=%d,ppid=%d\n",getpid(),getppid());
30     }
31     
32     return 0;
33 }

>gcc nfork1.c

>./a.out

(创建了5个进程！)

12、父子进程共享的内容

13、父子进程不共享全局变量

>touch shared.c

>vi shared.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<stdlib.h>
 4 
 5 int var = 100;
 6 
 7 int main()
 8 {
 9     pid_t pid = fork();
10     if(pid == 0){
11         //son
12         printf("var = %d,child,pid=%d,ppid=%d\n",var,getpid(),getppid());
13         var = 1001;
14         printf("var = %d,child,pid=%d,ppid=%d\n",var,getpid(),getppid());
15     }
16     else if(pid > 0){
17         //parent
18         sleep(1);//保证子进程能够修改var的值成功
19         printf("var = %d,parent,pid=%d,ppid=%d\n",var,getpid(),getppid());
20     }
21     
22     return 0;
23 }

(让子进程改，看结果)

>gcc shared.c

>./a.out

(让父进程改，看结果)

>vi shared.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<stdlib.h>
 4 
 5 int var = 100;
 6 
 7 int main()
 8 {
 9     pid_t pid = fork();
10     if(pid == 0){
11         //son
12         printf("var = %d,child,pid=%d,ppid=%d\n",var,getpid(),getppid());
13         var = 1001;
14         printf("var = %d,child,pid=%d,ppid=%d\n",var,getpid(),getppid());
15         sleep(3);
16         printf("var = %d,child,pid=%d,ppid=%d\n",var,getpid(),getppid());
17     }
18     else if(pid > 0){
19         //parent
20         sleep(1);//保证子进程能够修改var的值成功
21         printf("var = %d,parent,pid=%d,ppid=%d\n",var,getpid(),getppid());
22         var = 2000;
23         printf("var = %d,parent,pid=%d,ppid=%d\n",var,getpid(),getppid());
24     }
25     
26     return 0;
27 }

>gcc shared.c

>./a.out

》结论：即使是全局变量，父子进程也不共享。(读时共享，写时复制。)

14、execlp函数介绍

>man execl

》execl作用：执行其他程序

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

》exelp作用：执行程序的时候，使用PATH环境变量，执行的程序可以不用加路径

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

　　file 要执行的程序

　　arg 参数列表

　　参数列表最后需要一个NULL作为结尾(哨兵)

　　返回值：只有失败才返回

>touch execl.c

>vi execl.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 
 4 int main()
 5 {
 6     //int execlp(const char *file,const char *arg,...) /*(char *)NULL */
 7     execlp("ls", "ls", "-l", "--color=auto",NULL);//如果使其执行错误，返回，把第一个ls改为非法的lsxxx
 8     //不需要判断返回值
 9     perror("exec err");
10     return 0;
11 }

>gcc execl.c

>./a.out

>vi execl.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 
 4 int main()
 5 {
 6     //int execlp(const char *file,const char *arg,...) /*(char *)NULL */
 7     //execlp("ls", "ls", "-l", "--color=auto",NULL);
 8     execl("/bin/ls", "ls", "-l", "--color=auto",NULL);
 9     //不需要判断返回值
10     perror("exec err");
11     printf("hello\n");
12     return 0;
13 }

>gcc execl.c

>./a.out

15、exec函数规律

16、exel实现自定义程序

>touch fpe.c

>vi fpe.c

1 #include<stdio.h>
2 #include<unistd.h>
3 
4 int main()
5 {
6     int a = 10;
7     int b = a/0;
8     return 0;
9 }

>make

>./fpe

(报错：浮点数例外(核心已转储))

>touch execl.c

>vi execl.c

 1 #include <stdio.h>
 2 #include <unistd.h>
 3 
 4 int main()
 5 {
 6     execl("./fpe", "fpe", NULL);
 7     
 8     printf("bye bye!\n");
 9     return 0;
10 }

>gcc execl.c

>./a.out

(报错：浮点数例外(核心已转储))

17、孤儿进程与僵尸进程

》孤儿进程：父亲死了，子进程被init进程领养。

》僵尸进程：子进程死了，父进程没有回收子进程的资源(PCB)。

>touch orphan.c

>vi orphan.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 
 4 int main()
 5 {
 6     pid_t pid = fork();
 7     if(pid == 0){
 8         //子进程
 9         while(1){
10             printf("I am a child,pid=%d,ppid=%d\n",getpid(), getppid());
11             sleep(1);
12         }
13     }
14     else if(pid > 0){
15         //父进程的逻辑
16         printf("I am parent,pid=%d,ppid=%d\n",getpid(),getppid());
17         sleep(5);
18         printf("I am parent,I will die!\n")
19     }
20     
21     printf("End ....\n");
22     return 0;
23 }

>gcc orphan.c

>./a.out

(Ctrl+c无法结束子进程，因为子进程脱离shell，只能打开另一个终端，ps ajx查看pid，然后用kill -9 pid杀死)

>touch zoombie.c

>vi zoombie.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 
 4 int main()
 5 {
 6     pid_t pid = fork();
 7     if(pid == 0){
 8         //子进程
 9         printf("I am child,pid=%d,ppid=%d\n",getpid(), getppid());
10         sleep(2);
11         printf("I am child,I will die\n");
12     }
13     else if(pid > 0){
14         //父进程的逻辑
15         while(1){
16             printf("I am parent,pid=%d\n",getpid());
17             sleep(1);    
18         }
19     }
20     return 0;
21 }

>gcc orphan.c

>./a.out

(打开另一个终端查看 >ps aux | grep a.out)

(如果想研究下，使用man ps查看，然后用/zombie定位到)

》如何回收僵尸进程资源？

杀死父亲，init领养，负责回收。

18、wait函数简单使用和说明

》wait作用：1)阻塞等待；2)回收子进程资源；3)知道子进程的死亡原因

man 2 wait

pid_t wait(int *status);

　　status 传出参数

　　返回值：成功返回终止的子进程ID，失败返回-1

子进程的死亡原因：

　　正常死亡 WIFEXITED

　　　　如果WIFEXITED为真，使用WEXITSTATUS得到退出状态。

　　非正常死亡WIFSIGNALED

　　　　如果WIFSIGNALED为真，使用WTERMSIG得到信号

19、wait回收并且查看死亡原因

>touch wait.c

>vi wait.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<sys/types.h>
 4 #include<sys/wait.h>
 5 
 6 int main()
 7 {
 8     pid_t pid = fork();
 9     if(pid == 0){
10         //子进程
11         printf("I am child,I will die\n");
12         sleep(2);
13         while(1){//迁怒，等待kill杀死，非正常死亡
14             printf("I am child,guo lai da wo!\n");
15             sleep(1);
16         }
17         //正常死亡的两种情况
18         //return 101;
19         //exit(101);
20     }
21     else if(pid > 0){
22         //父进程的逻辑
23         printf("I am parent,wait for child die!\n");
24         int status;
25         
26         pid_t wpid = wait(&status);
27         printf("wait ok,wpid=%d,pid=%d\n",wpid,pid);
28         if(WIFEXITED(status)){
29             printf("child exit with %d\n",WEXITSTATUS(status));
30         }
31         if(WIFSIGNALED(status)){
32             printf("child killed by %d\n",WTERMSIG(status));
33         }
34         while(1){
35             sleep(1);    
36         }
37     }
38     return 0;
39 }

>gcc wait.c

>./a.out

(打开另一个终端，使用ps aux|grep a.out查看pid，然后用kill -9 pid杀死子进程，原终端将会收到：child killed by 9；用kill pid杀死子进程，原终端将会收到：child killed by 15)

20、waitpid回收子进程

man waitpid

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

　　pid

　　　　<-1 组id

　　　　1 回收任意

　　　　0 回收和调用进程组id相同组内的子进程

　　　　>0 回收指定的pid

　　options

　　　　0与wait相同，也会阻塞

　　　　WNOHANG 如果当前没有子进程退出的，会立刻返回

　　返回值

　　　　如果设置了WNOHANG，那么如果没有子进程退出，返回0

　　　　　　如果有子进程退出，返回退出的pid

　　　　失败返回-1(没有子进程)

>touch waitpid.c

>vi waitpid.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<sys/types.h>
 4 #include<sys/wait.h>
 5 #include<stdlib.h>
 6 
 7 int main()
 8 {
 9     pid_t pid = fork();
10     if(pid == 0){
11         //子进程
12         printf("I am child,pid=%d\n",getpid());
13         sleep(2);
14     }
15     else if(pid > 0){
16         //父进程的逻辑
17         printf("I am parent,pid=%d\n",getpid());
18         
19         int ret;
20         while((ret = = waitpid(-1,NULL,WNOHANG)) == 0){
21             sleep(1);
22         }
23         printf("ret = %d\n",ret);
24         ret = waitpid(-1,NULL,WNOHANG);
25         if(ret < 0){
26             perror("wait err");
27         }
28         while(1){
29             sleep(1);
30         }
31     }
32     return 0;
33 }

>gcc waitpid.c

>./a.out

21、用wait回收多个子进程

>touch nfork_wait.c

>vi nfork_wait.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<sys/types.h>
 4 #include<sys/wait.h>
 5 #include<stdlib.h>
 6 
 7 int main()
 8 {
 9     int n = 5;
10     int i = 0;
11     pid_t pid;
12     for(i = 0; i < 5; i++){
13         pid = fork();
14         if(pid == 0){
15             printf("I am child,pid=%d\n",getppid());
16             break;
17         }
18     }
19     sleep(i);
20     if(i == 5){
21         for(i = 0; i < 5; i++){
22             pid_t wpid = wait(NULL);
23             printf("wpid = %d\n",wpid);
24         }
25         while(1){
26             sleep(1);
27         }
28     }
29     return 0;
30 }

>gcc nfork_wait.c

>./a.out

(打开另一个终端，使用ps aux|grep a.out查看pid，看回收是否成功)

22、waitpid回收多个子进程

>touch nfork_waitpid.c

>vi nfork_waitpid.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<sys/types.h>
 4 #include<sys/wait.h>
 5 #include<stdlib.h>
 6 
 7 int main()
 8 {
 9     int n = 5;
10     int i = 0;
11     pid_t pid;
12     for(i = 0; i < 5; i++){
13         pid = fork();
14         if(pid == 0){
15             printf("I am child,pid=%d\n",getppid());
16             break;
17         }
18     }
19     if(i == 5){
20         //parent
21         printf("I am parent!\n");
22         //如何使用waitpid回收？-1代表子进程都死了，都回收了
23         while(1){
24             pid_t wpid = waitpid(-1, NULL, WNOHANG);
25             if(wpid == -1){
26                 break;
27             }
28             else if(wpid > 0){
29                 printf("waitpid wpid=%d\n",wpid);
30             }
31         }
32         while(1){
33             sleep(1);
34         }
35     }
36     if(i < 5){
37         //sleep(i);
38         printf("I am child,i = %d,pid=%d\n",i,getpid());
39     }
40     return 0;
41 }

>gcc nfork_waitpid.c

>./a.out

(打开另一个终端，使用ps aux|grep a.out查看pid，看回收是否成功)

》作业

>touch fork_write.c

>vi fork_write.c

 1 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<sys/types.h>
 4 #include<sys/wait.h>
 5 #include<stdlib.h>
 6 #include<fcntl.h>
 7 #include<string.h>
 8 
 9 int main(int argc,char *argv[])
10 {
11     if(argc != 2){
12         printf("./a.out filename\n");
13         return -1;
14     }
15     int fd = open(argv[1],O_RDWR);
16     if(fd < 0){
17         perror("open err");
18         exit(1);
19     }
20     pid_t pid = fork();
21     if(pid == 0){
22         //son
23         write(fd,"hello\n",6);
24     }
25     else if(pid > 0){
26         //parent
27         sleep(1);
28         write(fd,"world\n",6);
29         wait(NULL);
30     }
31     
32     return 0;
33 }

>touch 11

>make

>ls -lrt

>./fork_write 11

>cat 11

1 hello
2 world

(没有覆盖，说明写时共享文件描述符，读写位置一样，一个进程写了，读写位置改变了，另一个进程受影响，所以可以跟着写。)

在学习Linux系统编程总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

AllisWell_WP
关注
Linux系统编程——特殊进程之僵尸进程-附件资源
03-05
Linux系统编程——特殊进程之僵尸进程-附件资源
ps -aux命令详解
aa52013140813的专栏
08-14 3914
Linuxps aux指令詳解 linux上进程有5种状态: 1. 运行(正在运行或在运行队列中等待) 2. 中断(休眠中, 受阻, 在等待某个条件的形成或接受到信号) 3. 不可中断(收到信号不唤醒和不可运行, 进程必须等待直到有中断发生) 4. 僵死(进程已终止, 但进程描述符存在, 直到父进程调用wait4()系统调用后释放) 5. 停止(进程收到SIGSTOP...
进程相关总结（Linux）
qq_59993282的博客
11-25 785
总结了进程相关知识，在Linux下练习进程相关指令和函数的用法
Linux进程概念
qq_66581313的博客
01-09 685
操作系统和硬件的关系 进程的理解
【Linux】进程的概念(1)
zxf123567的博客
03-20 375
进程,进程状态,linux环境变量
Linux常用指令之——ps aux
一颗奋起萌发的种子的博客
05-24 9004
命令常用于查看当前系统中运行的进程，以及它们所占用的资源和状态信息。可以通过对输出进行筛选和排序，进一步了解进程的性能和行为，以及对系统资源的使用情况进行监控和分析。或其他类似的命令来达到相同的效果。建议在使用时参考相关系统的文档和命令手册，以确保正确使用和解读输出结果。命令的输出结果可能会因为操作系统的不同而有所差异。是一个常用的命令行命令，用于列出当前系统中正在运行的进程的详细信息。输出的是所有用户的进程信息，其中。表示显示没有控制终端的进程。表示显示所有用户的进程，表示显示进程的详细信息，
Linux下C语言编程——进程通信
07-24
【Linux下C语言编程——进程通信】 在Linux操作系统中，进程通信（IPC，Inter-Process Communication）是不同进程之间交换信息的重要方式。本篇主要讨论Linux下的几种进程通信机制，包括POSIX无名信号量、System V...
基于Linux的网络编程——网络聊天程序
09-02
网络聊天程序是目前应用极为广泛的一种网络软件，对于方便人们的交流沟通非常有效，同时，作为一种典型的网络应用，编写网络聊天程序是学习基于Linux的网络编程的有效方法。 结合任务需求设计该程序，程序采用多...
Linux系统编程实验六进程间通信.docx
11-01
在本实验中，我们主要探讨了Linux系统编程中的两个核心概念：进程间通信（IPC，Inter-Process Communication）以及信号处理。实验环境是基于Linux的虚拟机，通过编写C语言程序来实现这些功能。 首先，我们关注的是...
操作系统实验：Linux下的进程控制实验
qq_45929428的博客
11-04 1万+
进程控制实验一、实验目的：二、实验平台：三、实验内容：1.进程的创建与销毁进程控制相关函数实验结果分析2.多进程并发执行time命令实验结果分析四、总结分析 一、实验目的： 加深对进程概念的理解，明确进程和程序的区别；掌握Linux操作系统的进程创建和终止操作，体会父进程和子进程的关系及进程状态的变化；进一步认识并发执行的实质，编写并发程序。 二、实验平台： 虚拟机：VMWare15.5.1 操作系统：CentOS7 64位 编辑器：Vim 编译器：Gcc 三、实验内容： 1.进程的创建与销毁 编写一段程序
linux之ps aux、ps -aux、ps -ef命令的区别
corleone_4ever的博客
03-31 7489
psaux、ps-aux、ps-ef的区别 先说说aux,-aux,-ef都什么意思 aux： ps a 显示现行终端机下的所有程序，包括其他用户的程序​​ ps u 以用户为主的格式来显示程序状况 ps x 显示所有程序，不以终端机来区分。​​ 所以，ps aux就是打印所有进程。​ -aux​ ​ps -aux 不同于"ps aux"。POSIX和UNIX的标准要求...
Linux_系统编程day01
scavenger1994的博客
03-10 244
将近日学习Linux基础编程，系统编程，网络编程的word笔记搬运过来，图片无法直接粘贴，就丢失掉了。日后工作学习中使用与扩充维护还是word笔记这篇文章图片很多，亏大了。系统编程day01内容简介：程序和进程         磁盘中的二进制文件，运行的程序，cpu，虚拟地址空间，物理内存并行和并发         时间碎片和多核pcb进程控制块         文件描述符，进程id进程三态   ...
ps -ef和ps -aux的区别
热门推荐
weixin_54514751的博客
08-11 1万+
ps -ef和ps aux的区别
Linux操作系统篇: 进程控制
最新发布
m0_74756975的博客
03-02 1268
使用_exit函数退出进程的方法我们并不经常使用，_exit函数也可以在代码中的任何地方退出进程，但是_exit函数会直接终止进程，并不会在退出进程前会做刷新，这和实现有关系，exit是库函数，_exit是系统调用，exit的实现是封装的_exit系统调用但包含了会刷新一下缓冲区，而_exit函数是系统调用，并没有缓冲区的概念，自然就不会刷新。使用exit函数退出进程前，exit函数会执行用户定义的清理函数、冲刷缓冲，关闭流等操作，然后再终止进程，而_exit函数会直接终止进程，不会做任何收尾工作。
【Linux】进程控制（进程创建、进程终止、进程等待、进程替换）
codewinter的博客
07-31 1365
进程创建、进程终止、进程等待、进程替换
进程等待与进程替换
m0_68678877的博客
11-10 194
linux进程等待与进程替换
Linux中ps命令ps -aux 和ps -ef 参数解释
巧克力配酸奶的博客
04-20 4728
Linux中 ps -aux 和 ps -ef 参数解释
【Linux系统编程】进程概念详解（什么是进程？如何查看进程？）
weixin_45031801的博客
11-28 1563
​ 在学习了【Linux系统编程】中的 操作系统和冯·诺依曼体系结构之后，我们已经对系统应该有了不错的了解，接下里我们将继续深入的了解操作系统最重要的的功能之一：进程管理。 那么操作系统是如何进行进程管理的呢？------很简单，先把进程描述起来，再把进程组织起来！ 那么进程又是什么呢？------所以本次博客将从进程讲起！ ​
Linux系统中查看父进程ID，进程ID，进程组ID，会话ID的方法：ps ajx
ctrigger的专栏
11-26 6967
Linux系统中查看父进程ID，进程ID，进程组ID，会话ID的方法：ps ajx [ycxie@localhost Workspace]$ ps ajx PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND 0 1 1 1 ? -1 Ss 0 0:02 /usr/lib/systemd/systemd --switche
Linux系统编程书籍——献给IT从业者
1. **Linux基础知识**：介绍Linux操作系统的基本概念，如进程管理、文件系统、设备驱动、网络通信等，这些都是系统编程的基础。 2. **进程与线程**：详细阐述进程的创建、同步、通信和调度机制，以及线程的概念和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值