Linux系统编程（三）——Linux下的进程

可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。从内核的角度看，进程由用户内存和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标识号（IDs）、虚拟内存表、打开文件的描述符、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。

单道程序，即在计算机内存中只允许一个程序运行。
多道程序设计技术是在计算机内存中存在同时存放几道相互独立的程序，使他们在管理程序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之间的状态，这些程序共享计算机系统资源，引入多道程序设计技术的根本目的是为了提高CPU利用率。
对于一个单CPU系统来书，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，CPU上运行的程序只有一个。
在多道程序设计模型中，多个进程轮流使用CPU。
时间片又称为量子或处理器片，是操作系统分配给每个正在运行的进程微观上的一段CPU时间。事实上，虽然一台计算机通常可能有多个CPU，但同一个CPU永远不可能真正的同时运行多个任务。
时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番的执行相应的时间，当所有进程处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。

三、并行与并发

并行：指在同一时刻，有多条指令在多个处理器上同时执行。
并发：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干份，使多个进程快速交替的执行。

四、进程控制块PCB

为了管理进程，内核必须对每个进程所做的事情进行清楚的描述，内核为每个进程分配一个PCB进程控制块，维护进程相关的信息，Linux内核的进程控制块是task_struct结构体。
在/usr/src/linux-headers-xxx/include/linux/sched.h文件中可以查看struct task_struct结构体定义。其内部成员有很多，我们只需要掌握以下部分即可：
- 进程id：系统中每个进程都有唯一的id，用pid_t类型表示，其实就是一个非负整数。
- 进程的状态：有就绪、运行、挂起、停止等状态。
- 进程切换时需要保存和恢复的一些CPU寄存器。
- 描述虚拟地址空间的信息
- 描述控制终端的信息
- 当前工作目录(Current working directiory)
- umask 掩码
- 文件描述符，包含很多指向file结构体的指针
- 和信号相关的信息
- 用户id和组id
- 会话和进程组
- 进程可以使用的资源上限

0x02 进程状态转换

一、进程的状态

进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换，在三态模型中，进程状态分为三个基本状态，即就绪态，运行态，阻塞态。在这五态模型中，进程分为新建态、就绪态、运行态、阻塞态、终止态。

运行态：进程占有处理器正在运行
就绪态：进程具备运行条件，等待系统分配处理器以便运行。当进程已分配到除CPU以外的所有必要资源后，只要再获得CPU，便可立即执行。在一个系统中处于就绪状态的进程可能有多个，通常将他们排成一个队列，称为就绪队列。
阻塞态：又称为等待态或睡眠态，指进程不具备运行条件，正在等待某个事件的完成。

新建态：进程刚被创建时的状态，尚未进入就绪队列。
终止态：进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程。

二、进程相关的命令

查看进程：

ps aux

ps ajx

a:显示终端上的所有进程，包括其他用户的进程。

u:显示进程的详细信息。

x:显示没有控制终端的进程。

j:列出与作业控制相关的信息。

查看当前终端所占的pts：tty
STAT参数的意义

可以在这看到有个STAT参数，其意义如下：

D：不可中断 Uniterruptible

R：正在运行，或在队列中的进程

S（大写）：处于休眠状态

T：停止或被追踪

Z：僵尸进程

W：进入内存交换（从内核2.6开始无效）

X：死掉的进程

<：高优先级

N：低优先级

s：包含子进程

+：位于前台的进程组

对于实时显示进程动态

使用top，可以在使用top命令时加上-d来指定显示信息更新的时间间隔，在top命令执行后，可以按以下按键对显示的结果进行排序：

M：根据内存使用量排序

P：根据CPU占有率排序

T：根据进程运行时间长短排序

U：根据用户名来筛选进程

K：输入指定的PID杀死进程

对于杀死进程的处理

kill [-signal] pid

kill -l 列出所有信号

kill -SIGKILL 进程ID

kill -9 进程ID

killall name 根据进程名杀死进程

可以在进程后面加入&号，表示在后台运行，可以在当前终端输入一些指令。

三、进程号和相关函数

每个进程都由进程号来标识，其类型为pid_t（整型），进程号范围：0~32767。进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。
任何进程（除init进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID）。
进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID）。默认情况下，当前的进程号会当做当前的进程组号。

进程号和进程组相关的函数：

pid_t getpid(void);
pid_t getppid(void);
pid_t getpgid(pid_t pid)

0x03 进程的创建

终端也是个进程，在终端创建一个进程，该进程为子进程，子进程还可以创建新的子进程，形成进程树结构模型。

一、父子进程虚拟地址空间

fork以后，子进程的用户区数据和父进程一样，内核区也会拷贝过来，但是pid是不一样的。

实际上，更准确来说，Linux的fork()使用的是通过写时拷贝(copy-on-write)实现，写时拷贝是一种可以推迟甚至避免拷贝数据的技术。内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享的，注意：fork之后父子进程共享文件，fork产生的子进程与父进程相同的文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。（写时拷贝）

fork()创建子进程时继承了父进程的数据段、代码段、栈段、堆，注意从父进程继承来的是虚拟地址空间，同时也复制了页表（没有复制物理块）。因此，此时父子进程拥有相同的虚拟地址，映射的物理内存也是一致的（独立的虚拟地址空间，共享父进程的物理内存）。

二、GDB多进程调试

使用GDB调试的时候，GDB默认只能跟踪一个进程，可以在fork函数调用之前，通过指令设置GDB调试工具跟踪父进程或者是跟踪子进程，默认跟踪父进程。设置调试父进程或者子进程：

set follow-fork-mode [parent（默认）|child]

设置调试模式：

set detach-on-fork [on|off]

默认为on，表示调试当前进程时，其他的进程继续运行，如果为off，调试当前进程的时候，其他进程被GDB挂起。

三、代码

首先看看函数的解析：

#include <sys/types.h>

#include <unistd.h>

pid_t fork(void);

        作用：创建子进程

        返回值：

        返回两次，一次是在父进程中，一次是在子进程中。

                在父进程中返回创建的子进程的ID，在子进程中返回0。（可以通过fork返回值区别父进程以及子进程）

                返回-1，是在父进程中返回的，表示创建子进程失败，并且设置errorno

子进程失败的两个主要原因：

        - 当系统的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN

        - 系统内存不足时，这时errno的值被设置为ENOMEM

父子进程之间的关系：

区别：

        1.fork（）函数的返回值不同

                父进程中>0 返回的子进程的ID

                子进程中=0

        2.pcb中的一些数据

                当前进程的pid

                当前的进程的父进程的id ppid

                信号集

共同点：

在某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作。

        - 用户区数据

        - 文件描述符表

父子进程对变量是不是共享？

        - 刚开始的时候是一样的，共享的，如果修改了数据，不共享了。

        - 读时共享（子进程被创建，两个进程没有写的操作），写时拷贝

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

int main()
{
    pid_t pid = fork();
    //子进程从这开始执行
    // 判断是父还是子
    if(pid>0)
    {
        printf("pid:%d\n",pid);
        //如果大于0，返回的是创建子进程的进程号，是父进程
        printf("I am parent process,pid:%d,ppid:%d\n",getpid(),getppid());
    }
    else if(pid==0)
    {
        //当前是子进程
        printf("I am child process,pid:%d,ppid:%d\n",getpid(),getppid());
    }

    for(int i=0;i<5;i++)
    {
        //父子进程交替运行
        printf("i:%d,pid:%d\n",i,getpid());
        sleep(1);
    }

    return 0;
}

0x04 进程的控制

一、进程的退出

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

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

//status:是进程退出时的一个状态信息，父进程回收子进程资源的时候可以获取到。

这两个函数的区别可以看如下图：

对于使用可以看看如下代码的区别:

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

int main()
{
    printf("hello\n");
    printf("world");

    //exit(0);  会打印world 刷新了缓冲区
    //_exit(0); 不会打印world 没有刷新缓冲区，world留在了缓冲区
    
    return 0;
}

二、孤儿进程

父进程运行结束时，但子进程还结束在运行（未运行未结束），这样的子进程就称为孤儿进程(Orphan Process)
每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉的结束了它的生命周期，init进程就会处理它的一切善后工作。此时，子进程的父进程ppid为1。
因此孤儿进程并不会有什么危害。

三、僵尸进程

每个进程结束之后，都会释放掉自己地址空间中的用户数据，内核区的PCB没有办法自己释放掉，需要父进程去释放。
进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸进程。
僵尸进程不能被kill -9杀死。
这样就会导致一个问题，如果父进程不调用wait()或者waitpid()的话，那么保留的那段信息就不会被释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

四、进程回收

为了解决僵尸进程的问题，我们需要实现进程回收。

在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要是指进程控制块PCB信息（包括进程号、退出状态、运行时间等）。
父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。
wait和waitpid功能一样，区别在于wait会阻塞（等待），waitpid可以设置不阻塞，waitpid可以指定等待哪个子进程结束。
一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。

使用fork创建进程的话是进程数指数倍增长。需要使用if语句是防止其继续增长。

首先看看退出信息的相关宏函数：

WIFEXITED(status) 非0，进程正常退出
WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态(exit的参数)

WIFSIGNALED(status) 非0，进程异常终止
WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号

WIFSTOPPED(status) 非0，进程处于暂停状态
WSTOPSIG(status) 如果上宏为帧，获取使进程暂停的信号的编号
WIFCONTINUED(status) 非0，进程暂停后已经继续运行

那么如果我们要等待子进程的结束，可以先看看wait函数：

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait(int *wstatus);

        作用：等待任意一个子进程结束，如果任意一个子进程结束啦，此函数会回收子进程的资源。

        参数：进程退出时的状态信息，传入的是一个int类型的地址，传出参数

返回值：

        成功，会返回被回收的子进程的id

        失败，-1（所有的子进程都结束了，调用函数失败）

调用wait函数，这个进程就会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒。（相当于继续往下执行）

如果没有子进程了，这个函数立刻返回-1；如果子进程都已经结束了，也会返回-1；

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    //有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    for(int i=0;i<5;i++)
    {
        pid = fork();
        if(pid==0)
        {
            break;  //防止产生孙子进程
        }
    }
    if(pid>0)
    {
        while(1)
        {
            //father
            printf("parent,pid=%d\n",getpid());
            //int ret = wait(NULL);
            int st;
            int ret = wait(&st);
            if(ret==-1)
            {
                break;
            }
            if(WIFEXITED(st))
            {
                //是不是正常退出
                //其实就是exit(0)，取决于exit中的函数
                printf("status:%d\n",WEXITSTATUS(st));

            }
            if(WIFSIGNALED(st))
            {
                //是不是异常终止
                //在后面终端操作 kill -9 就是9
                printf("who do this?:%d\n",WTERMSIG(st));
            }
            printf("child die,pid=%d\n",ret);
            sleep(1);
        }
    }
    else if(pid==0)
    {
        //使用while在另外一个终端杀死子进程
        //while(1)
        //{
            printf("child,pid=%d\n",getpid());
            sleep(1);
            exit(0);
        //}
    }


    return 0;   //exit(0)
}

那么接下来看看waitpid()函数：

#include <sys/types.h>

#include <sys/wait.h>

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

        功能：回收指定进程号的子进程，可以设置是否阻塞。

        参数：

                pid:

                        - >0：表示某个子进程的pid

                        - =0：回收当前进程组的所有子进程

                        - =-1：表示要回收所有的子进程，相当于wait() 最常用

                        - <-1：某个进程组的组id的绝对值，回收指定进程组中的子进程

                options：设置阻塞或者非阻塞

                        0:阻塞

                        WNOHANG：非阻塞

        返回值：

                >0：返回子进程的id

                =0：options=WNOHANG，表示还有子进程活着

                =-1：错误，或者没有子进程

#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    //有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    for(int i=0;i<5;i++)
    {
        pid = fork();
        if(pid==0)
        {
            break;  //防止产生孙子进程
        }
    }
    if(pid>0)
    {
        while(1)
        {
            //father
            sleep(1);
            printf("parent,pid=%d\n",getpid());
            //int ret = wait(NULL);
            int st;
            int ret = waitpid(-1,&st,WNOHANG);
            if(ret==-1)
            {
                break;
            }
            if(ret==0)
            {
                //说明还有子进程存在
                continue;
            }else if(ret > 0)
            {
                continue;
            }
            else if(ret>0)
            {
                if(WIFEXITED(st))
                {
                    //是不是正常退出
                    //其实就是exit(0)，取决于exit中的函数
                    printf("status:%d\n",WEXITSTATUS(st));

                }
                if(WIFSIGNALED(st))
                {
                    //是不是异常终止
                    //在后面终端操作 kill -9 就是9
                    printf("who do this?:%d\n",WTERMSIG(st));
                }

                printf("child die,pid=%d\n",ret);
            }

            sleep(1);
        }
    }
    else if(pid==0)
    {
        //使用while在另外一个终端杀死子进程
        while(1)
        {
            printf("child,pid=%d\n",getpid());
            sleep(1);
        }
        exit(0);
    }
    return 0;   //exit(0)
}

五、函数execl()

#include <unistd.h>

int execl(const char *pathname, const char *arg, ...);

        -参数：

                -path：需要指定的执行的文件的路径或者名称。

                        a.out（相对路径）

                        /home/... （绝对路径）推荐

        - arg：执行可执行文件所需要的参数列表

                第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称

                从第二个参数开始往后，就是程序执行所需要的参数列表

                参数最后需要以NULL结束。

        -返回值：

                只有当调用失败，才会有返回值，返回-1，并且设置errno。

                如果调用成功，则没有返回值。

int execlp(const char *file, const char *arg, ...);

        -会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。

        -参数：

                -file：需要执行的可执行文件的文件名

                a.out ps

int execv(const char* path,char *const argv[]);

        argv是需要的参数的一个字符串数组

                char *argv[] = {"ps","aux",NULL};

                execv("/bin/ps",argv);

还有其他函数诸如：

int execle(const char *pathname, const char *arg, ...);

int execvp(const char *file, char *const argv[]);

int execvpe(const char *file, char *const argv[],char *const envp[]);

-l(list) 参数地址列表，以空指针结尾。

-v(vector) 存有各参数地址的指针数组的地址。

-p(path) 按PATH环境变量指定的目录搜索可执行文件

-e(environment) 存有环境变量字符串地址的指针数组的地址（列出地址路径）

这个函数是可以调用其他的可执行文件进行执行程序，看看代码的实现：

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

int main()
{
    // 创建一个子进程，在子进程中执行exec函数族中的函数
    pid_t pid=fork();
    if(pid>0)
    {
        printf("I am parent process,pid:%d\n",getpid());
        //防止孤傲进程
        sleep(1);
    }
    else if(pid==0)
    {
        //执行自己的程序
        //execl("hello","hello",NULL);
        //执行Linux下的程序 which ps得到路径
        //execl("/bin/ps","/bin/ps","aux",NULL);
        //从env下找路径
        execlp("ps","ps","aux",NULL);
        //在子进程中，下面的代码会被替换掉
        printf("I am child process,pid:%d\n",getpid());
    }

    for(int i=0;i<3;i++)
    {
        printf("i=%d,pid=%d\n",i,getpid());
    }

    return 0;
}

0x05 进程间的通信

一、进程间通讯概念

进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。但是进程并不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信（IPC:Inter Processes Communication）。
进程间通信的目的：

数据传输：一个进程需要将它的数据发送至另一个进程。

通知事件：一个进程需要向另一个或一组进程发送消息，通知他们发生了某种事件（如进程终止时要通知父进程）。

资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。

进程控制：有些进程希望完全控制另一个进程的执行（如debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

二、匿名管道

管道也叫无名管道，它是Unix系统IPC（进程间通信）的最古老形式，所有的Unix系统都支持这种通信机制。
统计一个目录中文件的数目命令：ls | wc -l，为了执行该命令，shell创建了两个进程来执行ls和wc。

管道的特点

管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。
管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。
一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。
通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和他们被写入管道的顺序是完全一样的。
在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。
从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用lseek()来随机的访问数据。
匿名管道只能在具有公共祖先的进程（父进程与子进程，或两个兄弟进程，具有亲缘关系）之间使用。

为什么可以使用管道来进行进程间的通讯

可以理解为磁盘上的一处内存，使用fork进行操作后，父子进程都可以进行读写，都是位于同一个区域，因为fork后复制的是文件描述符表，都是一样的。

管道的数据结构

环形队列。使用逻辑的手段进行实现：

管道是一种队列类型的数据结构，它的数据从一端输入，另一端输出。管道最常见的应用是连接两个进程的输入输出，即把一个进程的输出编程另一个进程的输入。

可以通过命令： ulimit -a来查看管道缓冲区的大小。

可以使用命令修改大小：ulimit -p

当然，可以通过程序来获取管道的大小：

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

int main()
{
    int pipefd[2];

    int ret = pipe(pipefd);
    //获取管道大小
    long size = 0;
    size = fpathconf(pipefd[0],_PC_PIPE_BUF);

    printf("pipe size:%ld\n",size);

    return 0;
}

管道的读写特点及需要注意的特殊情况（假设阻塞IO的操作）

所有的指向管道写端的文件描述符都关闭了，（管道写端的引用计数为0），有进程从管道的读端读数据，管道中剩余的数据被读取以后，再次去read会返回0，第一次是读到的字节数。就像读到文件末尾一样。
如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，再次read会阻塞，直到管道中有数据可以读了，才读数据并返回。
如果所有指向管道读端的文件描述符都关闭了（管道读端引用计数为0），这个时候有向管道中写数据，那么该进程会收到一个信号SIGPIPE，通常会导致进程异常终止。
如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候，再次去调用write，会阻塞，直到管道中有空位置，才写入数据并返回。

总结：

        读管道：管道中有数据，read返回实际读到的字节数。

                管道无数据：

                写端被全部关闭，read返回0，相当于读到文件的末尾。

                写端没有完全关闭，read阻塞等待。

        写管道：管道读端全部被关闭，进程异常终止（进程收到SIGPIPE信号）

                管道读端没有全部关闭：

                管道已满，write阻塞。

                管道没有满，write将数据写入，并返回实际写入的字节数。

可以看看代码：

#include <unistd.h>

int pipe(int pipefd[2]);

        功能：创建一个匿名管道，用于进程间通信。

        参数：int pipefd[2] 这个数组是一个传出参数

                        pipefd[0] 对应的是管道的读端

                        pipefd[1] 对应的是管道的写端

        返回值：返回文件描述符（具有文件特质，读取以及写入）

                        0 成功

                        -1 失败

注意：

匿名管道只能用于具有关系的进程之间的通信（父子进程、兄弟进程）

管道默认是阻塞的，如果管道中没有数据，read阻塞，如果管道满了，write阻塞

eg:

1.子进程发送数据给父进程，父进程读取到数据输出

2.子进程不断发送数据

对于第一种情况的代码比较简单，子进程发送数据给父进程，父进程读取到数据并且进行输出：

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

int main()
{
    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret==-1)
    {
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();
    if(pid>0)
    {
        //父进程
        //从管道的读取端读取数据
        char buf[1024] = {0};
        //阻塞
        int length = read(pipefd[0],buf,sizeof(buf));
        printf("parent recv:%s,pid:%d\n",buf,getpid());
    }
    else if(pid==0)
    {
        sleep(1);
        //子进程
        //写入
        char *str = "hellohello,i write something to you!";
        write(pipefd[1],str,strlen(str));
    }

    return 0;
}

那么对于第二种情况，子进程不断自己发送数据，这个时候就需要用到总结里面的结论，这个时候需要避免死锁，所以父子进程的读写顺序一定需要相反：

int main()
{
    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret==-1)
    {
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();
    if(pid>0)
    {
        //父进程
        //从管道的读取端读取数据
        printf("I am parent process,pid:%d\n",getpid());
        char buf[1024] = {0};
        while(1)
        {
            //阻塞
            int length = read(pipefd[0],buf,sizeof(buf));
            printf("parent recv:%s,pid:%d\n",buf,getpid());
            //清空
            bzero(buf,1024);
            //写入
            char *str = "hellohello,i write something to you!parent!!";
            write(pipefd[1],str,strlen(str));
            //没有延时会有bug 自己发自己收，一般我们不这么做，我们只弄单向流向
            //可以使用延迟，也可以使用close(pipefd[0])这样的形式去进行关闭，并且把对应程序删除
            sleep(2);
        }
    }
    else if(pid==0)
    {
        printf("I am child process,pid:%d\n",getpid());
        char buf[1024] = {0};
        while(1)
        {
            //向管道中写入数据
            char *str = "hellohello,i write something to you!child!!";
            write(pipefd[1],str,strlen(str));
            sleep(2);
            //避免互相阻塞，顺序一定要相反，否则出现死锁
            int length = read(pipefd[0],buf,sizeof(buf));
            printf("child recv:%s,pid:%d\n",buf,getpid());
            //清空
            bzero(buf,1024);
        }
        
    }

    return 0;
}

三、有名管道

匿名管道，由于没有名字，只能用于亲缘关系的进程间通信，为了克服这个缺点，提出了有名管道（FIFO），也叫命名管道、FIFO文件。
有名管道（FIFO）不同于匿名管道之处在于它提供了一个路径名与之关联，以FIFO的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信，因此，通过FIFO不相关的进程也能交换数据。
一旦打开了FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的IO系统调用（如read()\write()\close()）。与管道一样，FIFO也有一个写入端和读取端，并且从管道中读取数据的顺序和写入的顺序是一样的。FIFO的名称也由此而来：先入先出。
有名管道（FIFO）和匿名管道（PIPE）有一些特点是相同的，不一样的地方在于：
1. FIFO在文件系统作为一个特殊文件存在，但FIFO中的内容却存放在内存中。
2. 当使用FIFO的进程退出后，FIFO文件将继续保存在文件系统中以便以后使用。
3. FIFO有名字，不相关的进程可以通过打开有名管道进行通信。

有名管道的使用：

mkfifo 名字

可以看看代码：

创建fifo文件：

        1.通过命令：mkfifo名字

        2.通过函数：

#include <sys/types.h>

#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

参数：

        -pathname:管道名称的路径

        -mode：文件的权限和open的mode是一样的,八进制

返回值：

        0 成功

        -1 失败，设置errno

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

int main()
{
    // 判断文件是否存在
    int ret = access("fifo1",F_OK);
    if(ret = -1)
    {
        ret = mkfifo("fifo1",0664);

        if(ret == -1)
        {
            perror("mkfifo");
            exit(0);
        }
    }                                            

    return 0;
}

一旦使用了mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件IO函数可用于fifo。如close、read、write、unlink等。
FIFO严格遵循先进先出，对管道及FIFO的读总是从开始处返回数据，对他们的写则把数据添加到末尾。他们不支持诸如lseek()等文件定位操作。

注意事项：

一个为只读而打开一个管道的进程会阻塞，直到另一个进程为只写打开管道。
一个为只写而打开一个管道的进程会阻塞，直到另一个进程为只读打开管道。

总结：

读管道：

管道中有数据：read返回实际读到的字节数。

管道中无数据：管道写端被全部关闭，read返回0（相当于读到文件末尾）。

管道写端没有全部被关闭，read阻塞等待。

写管道：

管道读端被全部关闭，进程异常终止（收到SIGPIPE）

管道读端没有全部关闭：

管道已经满了，write会阻塞。

管道没有满，write将数据写入，并返回实际写入的字节数。

四、使用有名管道实现一个聊天的功能

思路：

通过有名管道完成一个聊天的功能，需要创建两个有名管道：
进程A：
    - 以只写的方式打开管道1
    - 以只读的方式打开管道2
    - 循环写读数据while(1)
    {
        获取键盘录入的数据（fgets()））
        写管道1

        读管道2

    }
进程B：
    - 以只读的方式打开管道1
    - 以只写的方式打开管道2
    - 循环读写数据while(1)
    {
        读管道1

        获取键盘录入的数据（fgets()））
        写管道2
    }

对于这种半双工的通讯，我们需要声明两个管道，一个管道是A向B的传输，另一个管道是B向A的传输，那么对于进程A的代码可以这么写：

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

int main()
{
    //判断管道文件是否存在
    int ret = access("fifo1",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo1",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    ret = access("fifo2",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo2",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    
    //以只写的方式打开fifo1
    int fdw = open("fifo1",O_WRONLY);
    if(fdw == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo1 success! waiting write in ... \n");

    //以只读的方式打开fifo2
    int fdr = open("fifo2",O_RDONLY);
    if(fdr == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo2 success! waiting read in ... \n");

    char buf[128];

    //循环写读数据
    while(1)
    {
        memset(buf,0,128);
        //获取标准输入的数据
        fgets(buf,128,stdin);
        //写数据
        ret = write(fdw,buf,strlen(buf));
        if(ret == -1)
        {
            perror("write");
            exit(0);
        }
        //读管道数据
        memset(buf,0,128);
        ret = read(fdr,buf,128);
        if(ret<=0)
        {
            perror("read");
            break;
        }
        printf("buf:%s\n",buf);
    }
    //关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

那么对于进程B的代码需要这么写：

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

int main()
{
    //判断管道文件是否存在
    int ret = access("fifo1",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo1",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    ret = access("fifo2",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo2",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    
    //以只读的方式打开fifo1
    int fdr = open("fifo1",O_RDONLY);
    if(fdr == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo1 success! waiting read in ... \n");

    //以只写的方式打开fifo2
    int fdw = open("fifo2",O_WRONLY);
    if(fdw == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo2 success! waiting write in ... \n");

    char buf[128];

    //循环读写数据
    while(1)
    {
        //读管道数据
        memset(buf,0,128);
        ret = read(fdr,buf,128);
        if(ret<=0)
        {
            perror("read");
            break;
        }
        printf("buf:%s\n",buf);

        memset(buf,0,128);
        //获取标准输入的数据
        fgets(buf,128,stdin);
        //写数据
        ret = write(fdw,buf,strlen(buf));
        if(ret == -1)
        {
            perror("write");
            exit(0);
        }
    }
    //关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

0x06 内存映射

内存映射是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。

一、通过内存映射实现进程通信

那么这样我们也可以通过使用内存映射来实现进程间的通信，思路在于：

1.有关系的进程（父子进程）

        -还没有子进程的时候

                -通过唯一的父进程，先创建内存映射区

        -有了内存映射区后，创建子进程

        -父子进程共享创建的内存映射区

2.没有关系的进程间通信

        -准备一个大小不是0的磁盘文件

        -进程1 通过磁盘文件创建内存映射区

                -得到一个操作这块内存的指针

        -进程2 通过磁盘文件创建内存映射区

                -得到一个操作这块内存的指针

        -使用内存映射区通信

注意：内存映射区通信，是非阻塞。

那么首先我们可以看看实现内存映射的函数mmap：

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
    -功能：将一个文件或者设备的数据映射到内存中
    -参数：
        -void *addr：NULL，由内核指定，否则为指定内存的首地址（我们无法知道）
        -length：要映射的数据的长度，这个值不能为0。建议使用文件的长度。可以使用stat以及lseek函数。
                给定分页的整数倍大小。
        -int prot：对申请的内存映射区的操作权限。 
            PROT_EXEC  可执行权限
            PROT_READ  读的权限
            PROT_WRITE 写权限
            PROT_NONE  没有权限
            要操作映射内存，必须要有读的权限。所以一般是一读权限，或者其他权限跟读权限按位或。
        - flag：
            MAP_SHARED：映射区的数据会自动和磁盘文件进行同步，进程间通讯，必须要设置这个选项。
            MAP_PRIVATE：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件。（copy on write）
         - fd：需要映射的那个文件的文件描述符
            通过open得到的，open是一个磁盘文件。
            注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。
                prot：PROT_READ                 open：只读、读写
                prot：PROTT_READ | PROT_WRITE   open：读写
                必须要有read，权限要小于open的权限。
        - off_t offset：映射的偏移量，一般不用，必须指定的是4K的整数倍，0表示不偏移。
    -返回值：返回创建的内存的首地址，如果失败，则返回MAP_FAILED,(void*) -1，并且设置errno。
        
int munmap(void *addr, size_t length);
        -功能：释放内存映射
        -参数:
            -addr:要释放的内存的首地址。
            -length：要释放的内存的大小，要和mmap函数中的length参数的值一样。

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

int main()
{
    //打开文件
    int fd = open("test.txt",O_RDWR);
    //获取文件大小
    int size = lseek(fd,0,SEEK_END);
    //创建内存映射区
    void *ptr = mmap(NULL,size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    //创建子进程
    pid_t pid = fork();
    if(pid>0)
    {
        wait(NULL);
        char buf[64];
        strcpy(buf,(char *)ptr);
        printf("read date:%s\n",buf);
        
    }
    else if(pid==0)
    {
        strcpy((char *)ptr,"hello my parent!!");
    }
    //关闭内存映射区
    munmap(ptr,size);

    return 0;
}

二、匿名映射

不需要文件实体进行一个内存映射，也可以用于做父子进程间的通信（只可以父子进程间）。

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

int main()
{
    //1. 创建匿名映射区
    int length = 4096;
    void *ptr = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0);
    if(ptr==MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }

    //父子进程间通信
    pid_t pid=fork();

    if(pid>0)
    {
        //父进程
        strcpy((char *)ptr,"hello world");
        wait(NULL);
    }
    else if(pid==0)
    {
        //子进程
        sleep(1);
        printf("%s\n",(char *)ptr);
    }

    //释放
    int ret = munmap(ptr,length);
    if(ret==-1)
    {
        perror("munmap");
        exit(0);
    }

    return 0;
}

三、通过内存映射实现文件拷贝

1.对原始的文件进行内存映射。

2.创建一个新文件并拓展

3.把新文件的数据映射到内存中

4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中

5.释放资源

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

int main()
{
    //1.对原始的文件进行内存映射。
    int fd = open("chat.txt",O_RDWR);
    if(fd==-1)
    {
        perror("open");
        exit(0);
    }
    //获取文件长度便于下面扩展
    int len = lseek(fd,0,SEEK_END);

    //2.创建一个新文件并拓展
    int fd1 = open("cpy.txt",O_RDWR|O_CREAT,0664);
    if(fd1==-1)
    {
        perror("open");
        exit(0);
    }
    //对新创建的文件进行扩展
    truncate("cpy.txt",len);
    write(fd1," ",1);

    //3.把新文件的数据映射到内存中
    void *ptr = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    void *ptr1 = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd1,0);

    if(ptr==MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    if(ptr1==MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }

    //内存拷贝
    memcpy(ptr1,ptr,len);

    //释放资源
    munmap(ptr1,len);
    munmap(ptr,len);

    close(fd1);
    close(fd);

    return 0;
}

四、内存映射注意事项

如果对mmap的返回值(ptr)做++操作(ptr++)，是否可以munmap成功关闭内存映射区？

可以对其进行++操作，但是不建议，因为munmap会不能正确释放，需要保存地址。
如果open时O_RDONLY，mmap时port参数指定PROT_READ|PROT_WRITE会怎么样？

错误，返回MAP_FAILED；open函数中的权限建议和port参数的权限保持一致。
如果文件偏移量为1000怎么办？

偏移量里必须是4k的整数倍，返回MAP_FAILED
mmap什么情况下会调用失败？
- 第二个参数：length = 0
- 第三个参数：port（只指定了写权限或权限超过open的权限）
- 偏移量不是4k整数倍
可以open的时候O_CREAT一个新文件来创建映射区吗？

可以的，但是创建的文件大小如果为0的话，肯定不行。可以对新的文件进行扩展，使用lseek，truncate。
mmap后关闭文件描述符，对mmap映射有没有影响？

比如：

int fd = open("XXX");

mmap(...fd,0);

close(fd);

这个时候映射区还存在，创建映射区的fd被关闭了，没有任何影响。
ptr越界操作会怎么样？

越界操作的是非法内存，会发生段错误。

0x07 共享内存

在这之前可能会联想到内存映射，但是共享内存跟内存映射是有区别的，也是进程间通讯的一种方式，也是方式最快的一种通讯方式。内存映射需要关联一个文件，需要通过文件的内存来进行进程间的通信，需要在内存中映射一段磁盘的地址。

那么对于共享内存，共享内存允许两个或者多个进程共享物理内存的同一块区域（通常被称为段）。由于一个共享内存段会称为一个进程用户空间的一部分，因此这种IPC机制无需内核介入。所有需要做的就是让一个进程将数据复制进共享内存中，并且这部分数据会对其他所有共享同一个段的进程可用。

与管道等要求发送进程将数据从用户空间的缓冲区复制进内核内存和接收进程将数据从内核内存复制进用户空间的缓冲区的做法相比，这种IPC技术的速度更快。

一、共享内存使用步骤

调用shmget()创建一个新共享内存段或取得一个既有共享内存段的标识符（即由其他进程创建的共享内存段）。这个调用将返回后续调用中需要用到的共享内存标识符。
使用shmat()来附上共享内存段，即使该段称为调用进程的虚拟内存的一部分。
此刻在程序中可以像对待其他可用内存那样对待这个共享内存段。为引用这块共享内存，程序需要使用由shmat()调用返回的addr值，它是一个指向进程的虚拟地址空间中该共享内存段的起点的指针。
调用shmdt()来分离共享内存段。在这个调用之后，进程就无法再引用这块共享内存了。这一步是可选的，并且在进程终止时会自动完成这一步。
调用shmctl()来删除共享内存段。只有当当前所有附加内存段的进程都与之分离之后内存段才会销毁。只有一个进程需要执行这一步。

二、共享内存操作函数

包含头文件：

#include <sys/ipc.h>
#include <sys/shm.h>

函数shmget():

int shmget(key_t key, size_t size, int shmflg);
    - 功能：创建一个新的共享内存段，或者获取一个既有的共享内存段的标识。
        新创建的内存段中的数据都会被初始化为0
    - 参数：
        - key : key_t类型是一个整形，通过这个找到或者创建一个共享内存。
                一般使用16进制表示，非0值
        - size: 共享内存的大小
        - shmflg: 属性
            - 访问权限
            - 附加属性：创建/判断共享内存是不是存在
                - 创建：IPC_CREAT
                - 判断共享内存是否存在： IPC_EXCL , 需要和IPC_CREAT一起使用
                    IPC_CREAT | IPC_EXCL | 0664
        - 返回值：
            失败：-1 并设置错误号
            成功：>0 返回共享内存的引用的ID，后面操作共享内存都是通过这个值。

函数*shmat:

void *shmat(int shmid, const void *shmaddr, int shmflg);
    - 功能：和当前的进程进行关联
    - 参数：
        - shmid : 共享内存的标识（ID）,由shmget返回值获取
        - shmaddr: 申请的共享内存的起始地址，指定NULL，内核指定
        - shmflg : 对共享内存的操作
            - 读 ： SHM_RDONLY, 必须要有读权限
            - 读写： 0
    - 返回值：
        成功：返回共享内存的首（起始）地址。  失败(void *) -1

函数shmdt:

int shmdt(const void *shmaddr);
    - 功能：解除当前进程和共享内存的关联
    - 参数：
        shmaddr：共享内存的首地址
    - 返回值：成功 0， 失败 -1

函数shmctl：

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    - 功能：对共享内存进行操作。删除共享内存，共享内存要删除才会消失，创建共享内存的进行被销毁了对共享内存是没有任何影响。
    - 参数：
        - shmid: 共享内存的ID
        - cmd : 要做的操作
            - IPC_STAT : 获取共享内存的当前的状态
            - IPC_SET : 设置共享内存的状态
            - IPC_RMID: 标记共享内存被销毁
        - buf：需要设置或者获取的共享内存的属性信息
            - IPC_STAT : buf存储数据
            - IPC_SET : buf中需要初始化数据，设置到内核中
            - IPC_RMID : 没有用，NULL

函数ftok：

key_t ftok(const char *pathname, int proj_id);
    - 功能：根据指定的路径名，和int值，生成一个共享内存的key
    - 参数：
        - pathname:指定一个存在的路径
            /home/xxx/Linux/a.txt
        - proj_id: int类型的值，但是这系统调用只会使用其中的1个字节
                   范围 ： 0-255  一般指定一个字符 'a'

三、代码例程

在这里先实现一个共享内存的写端：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {    

    // 1.创建一个共享内存
    int shmid = shmget(100, 4096, IPC_CREAT|0664);
    printf("shmid : %d\n", shmid);
    
    // 2.和当前进程进行关联
    void * ptr = shmat(shmid, NULL, 0);

    char * str = "helloworld";

    // 3.写数据
    memcpy(ptr, str, strlen(str) + 1);

    printf("按任意键继续\n");		//暂停一下
    getchar();

    // 4.解除关联
    shmdt(ptr);

    // 5.删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

那么写端写完后，可以写一个读端：

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main() {    

    // 1.获取一个共享内存
    int shmid = shmget(100, 0, IPC_CREAT);
    printf("shmid : %d\n", shmid);

    // 2.和当前进程进行关联
    void * ptr = shmat(shmid, NULL, 0);

    // 3.读数据
    printf("%s\n", (char *)ptr);
    
    printf("按任意键继续\n");
    getchar();

    // 4.解除关联
    shmdt(ptr);

    // 5.删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

这个也是进程间通信的一个小案例。当然用途也是挺小的。

四、共享内存总结

（一）操作系统如何知道一块共享内存被多少个进程关联？

共享内存维护了一个结构体struct shmid_ds 这个结构体中有一个成员 shm_nattch
shm_nattach 记录了关联的进程个数

可以使用 man 3 shmctl中可以得知这个结构体。

（二）共享内存操作命令

使用下面的命令只可以达到标记删除的效果（标识为0x00000），并没有真正的删除其共享内存段，要真正的移除共享内存段需要把所有有关的进程都退出。

（三）可不可以对共享内存进行多次删除 shmctl？

可以的，因为shmctl 标记删除共享内存，不是直接删除
什么时候真正删除呢？当和共享内存关联的进程数为0的时候，就真正被删除
当共享内存的key为0的时候，表示共享内存被标记删除了；
如果一个进程和共享内存取消关联，那么这个进程就不能继续操作这个共享内存。也不能进行关联。

（四）共享内存和内存映射的区别

共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）
共享内存效果更高。
在内存方面，共享内存中所有的进程操作的是同一块共享内存；内车钥匙中，每个进程在自己的虚拟地址空间中国有一个独立的内存。
数据安全方面，如果进程突然退出，共享内存是还存在的，但是对于内存映射，它是会消失的；如果运行进程的电脑死机了，数据存储在共享内存中是已经没有了，但是内存映射中的数据，由于磁盘文件中的数据还在，所以内存映射区的数据还在。
生命周期方面，内存映射区：进程退出，内存映射区销毁；共享内存：进程退出，共享内存还在，标记删除（所有的关联的进程数为0），或者关机，如果一个进程退出，会自动和共享内存进行取消关联。

0X08 守护进程

一、终端

可以通过如下命令来来查看当前终端的进程号。

echo $$

在Unix系统中，用户通过终端登录系统后得到一个shell进程，这个终端成为shell进程的控制终端，进程中，控制终端是保存在PCB中的信息，而fork()会复制PCB中的信息，因此由shell进程启动的其他进行的控制终端也是这个终端。
默认情况下（没有重定向），每个进程的标准输入、标准输出和标准错误输出都指向控制终端，进程从标准输入读也就是读用户的键盘输入，进程往标准输出或标准错误输出写也就是输出到显示屏上。
在控制终端输入一些特殊的控制键可以给前台进程发送信号，例如Ctrl+c会产生SIGINT信号，Ctrl+\会产生SIGQUIT信号。无法控制后台进程。

二、进程组

进程组和会话在进程之间形参了一种两级层次关系：进程组是一组相关进程的集合，会话是一组相关进程组的集合。进程组合会话是为支持shell作业控制而定义的抽象概念，用户通过shell能够交互式地在前台或后台执行命令。
进程组由一个或多个共享同一进程组标识符（PGID）的进程组成。一个进程组拥有一个进程组首进程，该进程是创建该组的进程，其进程ID为该进程组的ID，新进程会继承其父进程所属的进程组ID。
进程组拥有一个生命周期，其开始时间为首进程创建组的时刻，结束时间为最后一个成员进程退出组的时刻。一个进程可能会因为终止而退出进程组，也可能会因为加入了另一个进程组而退出进程组。进程组首进程无需是最后一个离开进程组的成员。

三、会话

会话是一组进程组的集合，会话首进程是创建该新会话的进程，其进程ID会称为会话ID。新进程会继承其父进程的会话ID。
一个会话中的所有进程共享单个控制终端。控制终端会在会话首进程首次打开一个终端设备时被建立。一个终端最多可能会成为一个会话的控制终端。
在任一时刻，会话中的其中一个进程组会称为终端的前台进程组，其他进程组会称为后台进程组。只有前台进程组中的进程才能控制终端中读取输入。当用户在控制终端中输入终端字符生成信号后，该信号会被发送到前台进程组中的所有成员。
当控制终端的链接建立起来之后，会话首进程会称为该终端的控制进程。

四、进程组、会话、控制终端之间的关系

可以先看看指令：

find / 2 > /dev/null | wc -l &
sort < longlist | uniq -c

那么在上述的图中，我们可以看到其bash进程为后台进程，这个进程组也是我们首个创建的进程组bash，可以看到我们的PGID（进程组）以及PID（进程编号）以及PGID（会话）都是400；那么接下来产生了一个编号为658的进程组，为什么是658，因为其首进程的PID为658，并且继承了会话ID400，还有父进程的PID400，那么下面一起诞生的进程，因为需要继承进程组的PGID，所以不一样的只有自己的PID，其sort以及uniq的道理也是一样的，这个最后产生的是一个前台进程，这里所有的进程的父进程都是bash。为什么这个进程是前台，因为前面的那一句话用了&号表示为后台进程。

在同一个时刻只能有个前台进程组。

五、操作函数

获取当前的进程组的id：pid_t getpgrp(void);
获取指定的进程组的id（也可以当前）：pid_t getpgid(pid_t pid);
设置当前进程组的id（分配到其他组）：int setpgid(pid_t pid, pid_t pgid);
获取指定的进程的会话id：pid_t getsid(pid_t pid);
设置会话id：pid_t setsid(void);

六、守护进程

守护进程（Daemon Process），也就是通常说的 Daemon 进程（精灵进程），是Linux 中的后台服务进程。它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以 d 结尾的名字。
特征
- 生命周期很长，守护进程会在系统启动的时候被创建并一直运行直至系统被关闭。
- 它在后台运行并且不拥有控制终端。没有控制终端确保了内核永远不会为守护进程自动生成任何控制信号以及终端相关的信号（如 SIGINT、SIGQUIT）。（长期的做服务）
Linux 的大多数服务器就是用守护进程实现的。比如，Internet 服务器 inetd，Web 服务器 httpd 等。

七、守护进程的创建步骤

执行一个fork()，之后父进程退出，子进程继续执行。进程组的组长以及会话的组长不可以是同一个，否则会产生会话冲突，所以需要子进程来创建会话。（必须）
子进程调用setsid()开启一个新的会话。目的是为了脱离原先的控制终端，并且防止父进程的会话与当前要产生的会话发生冲突，所以就可以产生一个脱离当前终端的进程，称为后台进程。（必须）
清除进程的umask以确保当守护进程创建文件目录和目录时拥有所需的权限。（不是必须的）
修改进程的当前工作目录，通常会改为根目录(/)，防止被卸载。（不是必须的）
关闭守护进程从其父进程继承而来的所有打开着的文件描述符，防止其操作控制终端，也防止无法正常卸载。（比如退出U盘前要关闭很多东西）（必须）
在关闭了文件描述符0、1、2之后，守护进程通常会打开/dev/null并使用dup2()使所有的这些描述符指向这个设备。（重定向输出，在这个设备中的输出都会被丢弃）（必须）
核心业务逻辑（必须）

那么可以看看代码的实现一个守护进程，每隔两秒获取一下系统时间，将这个时间写入到磁盘文件中，如果需要杀死这个进程，需要使用kill：

/*
    写一个守护进程，每隔2s获取一下系统时间，将这个时间写入到磁盘文件中。
*/

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

void work(int num) {
    // 捕捉到信号之后，获取系统时间，写入磁盘文件
    time_t tm = time(NULL);
    struct tm * loc = localtime(&tm);
    // char buf[1024];
	// 打印需要可以打开这个，屏蔽下面的那个
    // sprintf(buf, "%d-%d-%d %d:%d:%d\n",loc->tm_year,loc->tm_mon
    // ,loc->tm_mday, loc->tm_hour, loc->tm_min, loc->tm_sec);

    // printf("%s\n", buf);

    char * str = asctime(loc);
    int fd = open("time.txt", O_RDWR | O_CREAT | O_APPEND, 0664);
    write(fd ,str, strlen(str));
    close(fd);
}

int main() {

    // 1.创建子进程，退出父进程
    pid_t pid = fork();

    if(pid > 0) {
        exit(0);
    }

    // 2.将子进程重新创建一个会话
    setsid();

    // 3.设置掩码
    umask(022);

    // 4.更改工作目录
    chdir("/home/xxx/");

    // 5. 关闭、重定向文件描述符
    // 运行后就不会在当前终端输入信息了，如果需要打印，把他屏蔽了
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, STDIN_FILENO);
    dup2(fd, STDOUT_FILENO);
    dup2(fd, STDERR_FILENO);

    // 6.业务逻辑

    // 捕捉定时信号
    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = work;
    sigemptyset(&act.sa_mask);
    sigaction(SIGALRM, &act, NULL);

    struct itimerval val;
    val.it_value.tv_sec = 2;
    val.it_value.tv_usec = 0;
    val.it_interval.tv_sec = 2;
    val.it_interval.tv_usec = 0;

    // 创建定时器
    setitimer(ITIMER_REAL, &val, NULL);

    // 不让进程结束
    while(1) {
        sleep(10);
    }

    return 0;
}