OS | Process

linux多进程

1. fork()创建进程，创建一份父进程的拷贝；在父进程中返回的是子进程id，在子进程中返回的是0；失败时返回-1；

2. fork()经常和exec()结合，exec() 覆盖了原进程的空间，转而执行其他程序；

3. 杀掉父进程，不会同时杀掉子进程；

孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这个子进程称之为僵尸进程。系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程。孤儿进程并不会有什么危害。

当我们寻求如何消灭系统中大量的僵死进程时，答案就是把产生大 量僵死进程的那个元凶枪毙掉（也就是通过kill发送SIGTERM或者SIGKILL信号啦）。枪毙了元凶进程之后，它产生的僵死进程就变成了孤儿进程，这些孤儿进程会被init进程接管，init进程会wait()这些孤儿进程，释放它们占用的系统进程表中的资源，这样，这些已经僵死的孤儿进程 就能瞑目而去了。

避免zombie的方法：

• 忽略信号SIGCHLD， signal(SIGCHLD,SIG_IGN);
• 父进程中调用wait或waitpid；
• 调用两次fork();父进程一次fork()后产生一个子进程随后立即执行waitpid(子进程pid, NULL, 0)来等待子进程结束，然后子进程fork()后产生孙子进程随后立即exit(0)。这样子进程顺利终止（父进程仅仅给子进程收尸，并不需要子进程的返回值），然后父进程继续执行。这时的孙子进程由于失去了它的父进程（即是父进程的子进程），将被转交给Init进程托管。于是父进程与孙子进程无继承关系了，它们的父进程均为Init，Init进程在其子进程结束时会自动收尸，这样也就不会产生僵尸进程了。ddkkk

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

 int main() {
     pid_t pid;     

     if ((pid = fork()) < ) {
         fprintf(stderr,"Fork error!\n");
         exit(-);
     } else if (pid == ) { // child
         if ((pid = fork()) < ) {
             fprintf(stderr,"Fork error!\n");
             exit(-);
         } else if (pid > ) {
             printf("child: %d, parent pid = %d\n", getpid(), getppid());
             exit(); // child exit
         } else {
             printf("grandchild: %d, parent pid = %d\n", getpid(), getppid());
             exit();
         }
     } else {
         printf("pid: %d\n", getpid());
         if (waitpid(pid, NULL, ) != pid) {
             fprintf(stderr,"Waitpid error!\n");
             exit(-);
         }
         return ;
     }
 }     

输出为：

 root@xxj-VirtualBox:~/interview# ./process
 pid:
 child: , parent pid =
 root@xxj-VirtualBox:~/interview# grandchild: , parent pid = 

 root@xxj-VirtualBox:~/interview# ps ax|grep
   ?        Ss     : init --user
   pts/    S+     : grep --color=auto 

父进程是7411，子进程的父进程是7411没错，孙进程是7413，现在它被init进程（1755）回收了。

打印父进程的父进程发现是5976，5976是bash的pid。

4. wait() 等待子进程；可以获取子进程的返回状态；

5. system()就是用fork()+exec()+wait()实现；

6. execlp()，每一个是可执行文件的路径，第二个参数开始就是arg0，arg1,...，所以arg0必须就是可执行文件名，最后一个arg必须是NULL;

 int main() {
     int pid = fork();
     if (pid < ) {
         fprintf(stderr, "fork failed");
         return -;
     } else if (pid == ) {
         cout << "child process" << endl;
         execlp("/bin/touch", "touch", "/root/lab/os/1", NULL);
     } else {
         cout << "pid of child:" << pid << endl;
         int status;
         wait(&status);
         cout << "status of child:" << status << endl;
     }
     return ;
 }

共享内存通信

1. shm_open打开或者创建共享内存object，名字必须以/开头；一开始大小为0；需要通过ftruncate()设置大小；

2. 用mmap将shared memory object映射到内存；映射为MAP_SHARED，这样在其他进程中可见；即使进程退出了，在没有调用shm_unlink之前，其他进程还是可以访问这一块区域的。

 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>

 int main() {
     int shmID = shm_open("/test", O_CREAT | O_RDWR, );
     if (shmID < ) {
         fprintf(stderr, "shm create failed\n");
         return -;
     }
     ftruncate(shmID, );
     char* p = (char*)mmap(NULL, , PROT_WRITE, MAP_SHARED, shmID, );
     for (int i = ; i < ; i++) {
         p[i] = '' + i % ;
     }
     munmap(p, );
     return ;
 }

 #include <stdio.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <fcntl.h>         

 int main() {
     int shmID = shm_open("/test", O_RDONLY, );
     if (shmID < ) {
         fprintf(stderr, "shm open fail\n");
         return -;
     }
     char* p = (char*)mmap(NULL, , PROT_READ, MAP_SHARED, shmID, );
     if (p == NULL) {
         return -;
     }
     for (int i = ; i < ; i++) {
         printf("%c ", p[i]);
     }
     printf("\n");

     shm_unlink("/test");
     munmap(p, );
     return ;
 }