Linux进程管理之如何创建和销毁进程

萱草解忘忧

Linux是一个多任务操作系统，进程管理是其核心功能之一。
本文将详细介绍如何在Linux中创建和销毁进程，包括示例代码和详细说明。

创建进程

在Linux中，可以使用多种方法创建新的进程。
以下是几种常见的方法：

1. 使用fork()系统调用

1. fork()

复制代码

系统调用是创建新进程的最常见方式。
它会创建一个与父进程几乎完全相同的子进程。

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. 
   
4. int main() {
   
5.     pid_t child_pid;
   
6. 
   
7.     child_pid = fork();
   
8. 
   
9.     if (child_pid == 0) {
   
10.         // 子进程代码
    
11.         printf("This is the child process\n");
    
12.     } else if (child_pid > 0) {
    
13.         // 父进程代码
    
14.         printf("This is the parent process, child PID: %d\n", child_pid);
    
15.     } else {
    
16.         // 创建进程失败
    
17.         perror("fork");
    
18.         return 1;
    
19.     }
    
20. 
    
21.     return 0;
    
22. }

复制代码

2. 使用exec()系列函数

1. exec()

复制代码

系列函数用于在当前进程中执行一个新的程序。
它们通常与

1. fork()

复制代码

一起使用，以替换子进程的内存映像。

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. 
   
4. int main() {
   
5.     pid_t child_pid;
   
6. 
   
7.     child_pid = fork();
   
8. 
   
9.     if (child_pid == 0) {
   
10.         // 子进程代码
    
11.         printf("This is the child process\n");
    
12. 
    
13.         // 在子进程中执行新程序
    
14.         execl("/bin/ls", "ls", "-l", NULL);
    
15.     } else if (child_pid > 0) {
    
16.         // 父进程代码
    
17.         printf("This is the parent process, child PID: %d\n", child_pid);
    
18.     } else {
    
19.         // 创建进程失败
    
20.         perror("fork");
    
21.         return 1;
    
22.     }
    
23. 
    
24.     return 0;
    
25. }

复制代码

3. 使用系统调用clone()

1. clone()

复制代码

系统调用与

1. fork()

复制代码

类似，但它允许更精细的控制，例如共享文件描述符和内存空间。

1. #define _GNU_SOURCE
   
2. #include <stdio.h>
   
3. #include <sched.h>
   
4. #include <stdlib.h>
   
5. #include <unistd.h>
   
6. 
   
7. int child_function(void *arg) {
   
8.     printf("This is the child process\n");
   
9.     return 0;
   
10. }
    
11. 
    
12. int main() {
    
13.     char *stack;
    
14.     char *stack_top;
    
15.     pid_t child_pid;
    
16. 
    
17.     stack = (char *)malloc(8192);
    
18.     if (stack == NULL) {
    
19.         perror("malloc");
    
20.         return 1;
    
21.     }
    
22. 
    
23.     stack_top = stack + 8192;
    
24. 
    
25.     child_pid = clone(child_function, stack_top, CLONE_VM | CLONE_FS | CLONE_FILES, NULL);
    
26. 
    
27.     if (child_pid == -1) {
    
28.         perror("clone");
    
29.         return 1;
    
30.     }
    
31. 
    
32.     printf("This is the parent process, child PID: %d\n", child_pid);
    
33. 
    
34.     return 0;
    
35. }

复制代码

销毁进程

Linux中，有几种方法可以销毁进程，其中最常见的是使用

1. exit()

复制代码

系统调用。
以下是一个示例：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. 
   
5. int main() {
   
6.     pid_t child_pid;
   
7. 
   
8.     child_pid = fork();
   
9. 
   
10.     if (child_pid == 0) {
    
11.         // 子进程代码
    
12.         printf("This is the child process\n");
    
13. 
    
14.         // 子进程退出
    
15.         exit(0);
    
16.     } else if (child_pid > 0) {
    
17.         // 父进程代码
    
18.         printf("This is the parent process, child PID: %d\n", child_pid);
    
19. 
    
20.         // 等待子进程退出
    
21.         wait(NULL);
    
22. 
    
23.         printf("Child process has exited\n");
    
24.     } else {
    
25.         // 创建进程失败
    
26.         perror("fork");
    
27.         return 1;
    
28.     }
    
29. 
    
30.     return 0;
    
31. }

复制代码

进程组与会话

在Linux中，进程组和会话是进程管理的重要概念。进程组是一组相关联的进程的集合，而会话则是一组进程组的集合。
进程组通常用于将多个相关的进程组织在一起，以便更好地进行控制和信号处理。
以下是创建进程组和会话的示例：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. 
   
5. int main() {
   
6.     pid_t child_pid;
   
7. 
   
8.     child_pid = fork();
   
9. 
   
10.     if (child_pid == 0) {
    
11.         // 子进程代码
    
12.         printf("This is the child process (PID: %d)\n", getpid());
    
13. 
    
14.         // 创建一个新会话并成为会话领袖
    
15.         if (setsid() == -1) {
    
16.             perror("setsid");
    
17.             return 1;
    
18.         }
    
19. 
    
20.         // 创建一个新进程组
    
21.         if (setpgid(0, 0) == -1) {
    
22.             perror("setpgid");
    
23.             return 1;
    
24.         }
    
25. 
    
26.         printf("Child process is in a new session and process group\n");
    
27.         sleep(10); // 保持进程运行10秒
    
28.     } else if (child_pid > 0) {
    
29.         // 父进程代码
    
30.         printf("This is the parent process, child PID: %d\n", child_pid);
    
31. 
    
32.         // 等待子进程退出
    
33.         wait(NULL);
    
34. 
    
35.         printf("Child process has exited\n");
    
36.     } else {
    
37.         // 创建进程失败
    
38.         perror("fork");
    
39.         return 1;
    
40.     }
    
41. 
    
42.     return 0;
    
43. }

复制代码

在上述示例中，子进程首先创建了一个新会话并成为会话领袖，然后创建了一个新进程组。
这将导致子进程脱离父进程的控制终端和进程组，成为一个独立的会话。这对于守护进程等后台任务非常有用。

杀死进程

在Linux中，可以使用

1. kill

复制代码

命令或

1. kill()

复制代码

系统调用来杀死进程。
以下是一个示例：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <signal.h>
   
5. 
   
6. void sig_handler(int signo) {
   
7.     if (signo == SIGTERM) {
   
8.         printf("Received SIGTERM, exiting...\n");
   
9.         exit(0);
   
10.     }
    
11. }
    
12. 
    
13. int main() {
    
14.     pid_t child_pid;
    
15. 
    
16.     child_pid = fork();
    
17. 
    
18.     if (child_pid == 0) {
    
19.         // 子进程代码
    
20.         printf("This is the child process (PID: %d)\n", getpid());
    
21. 
    
22.         // 注册信号处理函数
    
23.         signal(SIGTERM, sig_handler);
    
24. 
    
25.         while (1) {
    
26.             // 子进程持续运行
    
27.             sleep(1);
    
28.         }
    
29.     } else if (child_pid > 0) {
    
30.         // 父进程代码
    
31.         printf("This is the parent process, child PID: %d\n", child_pid);
    
32. 
    
33.         // 等待一段时间后向子进程发送SIGTERM信号
    
34.         sleep(5);
    
35.         kill(child_pid, SIGTERM);
    
36.         printf("Sent SIGTERM to child process\n");
    
37. 
    
38.         // 等待子进程退出
    
39.         wait(NULL);
    
40. 
    
41.         printf("Child process has exited\n");
    
42.     } else {
    
43.         // 创建进程失败
    
44.         perror("fork");
    
45.         return 1;
    
46.     }
    
47. 
    
48.     return 0;
    
49. }

复制代码

在上述示例中，父进程通过

1. kill()

复制代码

系统调用向子进程发送

1. SIGTERM

复制代码

信号，以请求子进程优雅地退出。

总结

Linux进程管理是操作系统的核心功能之一，对于系统开发和管理人员来说是重要的知识点。
本文详细介绍了如何创建和销毁进程，以及如何使用进程组和会话来组织进程。此外，还介绍了如何杀死进程。
希望本文提供的示例代码和详细说明有助于大家更好地理解和应用Linux进程管理的概念和技巧。也希望大家多多支持脚本之家。

来源:https://www.jb51.net/server/315729fzi.htm
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！