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()) < 0) {     
        fprintf(stderr,"Fork error!
");     
        exit(-1);     
    } else if (pid == 0) { // child 
        if ((pid = fork()) < 0) {      
            fprintf(stderr,"Fork error!
");     
            exit(-1);     
        } else if (pid > 0) {    
            printf("child: %d, parent pid = %d
", getpid(), getppid());     
            exit(0); // child exit   
        } else {
            printf("grandchild: %d, parent pid = %d
", getpid(), getppid());     
            exit(0);
        }
    } else {
        printf("pid: %d
", getpid());
        if (waitpid(pid, NULL, 0) != pid) {     
            fprintf(stderr,"Waitpid error!
");     
            exit(-1);     
        }     
        return 0; 
    }
}     

输出为：

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

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

父进程是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 < 0) {
        fprintf(stderr, "fork failed");
        return -1;
    } else if (pid == 0) {
        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 0;
}

 共享内存通信

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, 0666);
    if (shmID < 0) {
        fprintf(stderr, "shm create failed
");
        return -1;
    }
    ftruncate(shmID, 2014);
    char* p = (char*)mmap(NULL, 2014, PROT_WRITE, MAP_SHARED, shmID, 0);
    for (int i = 0; i < 2000; i++) {
        p[i] = '0' + i % 10;
    }
    munmap(p, 2014);
    return 0;
}

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

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

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