进程通信

一、进程通信

1.1什么进程通信

​ 进程通信是指两个或者多个进程实现数据层面的交互，因为其具有独立性，所以通信的成本比较高；

1.2进程通信的目的

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

​ 共享：多个进程之间共享同样的资源。

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

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

1.3怎么实现进程通信

​ 1.让不同的进程看到同一份资源；

​ 2.由操作系统分配的特殊的内存空间，防止破坏进程的独立性不可以让进程创建同一份资源空间；

​ 3.进程通信本质上就是访问操作系统，所以需要使用系统调用接口，即操作系统设计了独立的通信模块隶属于文件系统；

​ 定制了两套标准System V(主要进行本机内部通信)和POSIX(网络通信)标准；即共有三种类型的方案，还有基于文件的通信方案管道，在没有独立通信模块之前是可以通过文件进行通信的；

二、基于文件的通信——管道

​ 管道是单向通信的，即半双工的，所以为了防止误操作，要将同时打开的读写端关闭其中的一个；

​ 管道的本质就是一个面向字节流的队列；

​ 不使用磁盘文件实现通信是因为，通信的数据没必要刷盘，仅仅是使用文件页缓冲区；

​ 管道是基于文件的通信方式，所以要使用write和read来实现通信；

2.1匿名管道

​ 管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流称为一个“管道” ；管道是一种内存级文件，不会将文件缓冲区的数据刷新到磁盘。

​ 将文件载入内存之后，此时文件=文件属性(inode结构)+文件内容(文件页缓冲区)+文件的相关操作(VFS虚拟文件系统实现的一切皆文件)；

​ 即使存在同时读写的方式打开文件，但是只是存在一个缓冲区，这时是不能够完成同时读写的，因为涉及到指针的偏移量，需要文件指针重新指向开头，才可以写完成后进行读取；

​ 匿名管道通过父子进程这类的血缘关系看到同一份资源；

2.1.1原理

​ 原理：通过创建子进程来实现父子进程看到同一份资源；为了能够实现读写不能只以一种方式将文件打开，否则父子进程就都是读或者都是写，所以需要有两种方式(读和写)将文件打开，这时操作系统会为进程创建两个file结构体对象，由于管道只支持单向通信，所以需要一个进程读的时候关闭写端，另一个进程写的时候关闭读端；

​ 双向通信使用两个管道完成；只有具有血缘关系的进程才可以进行管道通信，看到同一份资源；

​ 只是子继承父看到同样的信息，也符合通信的要求，但是对数据进行修改会因为进程的独立性导致写时拷贝，这样就看到的不是同一份资源了，所以要使用管道的方式进行；

2.1.2接口

int pipe(int pipefd[2]);
//pipefd是输出型参数是大小为2的整型数组，pipefd[0]是读文件描述符，pipefd[1]是写文件描述符；

2.1.3管道特征

​ 1.具有血缘关系的进程可以进行管道通信；

​ 2.管道只能进行单向通信；

​ 3.父子进程之间是会进行协同的，即同步和互斥；多执行流共享资源会出现访问冲突的问题(临界资源的竞争问题)，主要是为了保护管道文件的数据安全；

​ 4.管道是面向字节流的，即上层不关心管道里的数据是什么类型的，交由上层处理；

​ 5.管道是基于文件的，文件会随着进程的结束关闭；

2.1.4管道中的四种情况

​ 1.读写端正常，如果管道为空，读端就要进行阻塞；

​ 2.读写端正常，如果管道写满，写端就要进行阻塞；

​ 3.读端正常，写端关闭，读端就会读到0，但是读端不会进行阻塞；

​ 4.写端关闭，读端正常，对于操作系统是并不会做低效的事情的，所以操作系统会将正在写入的进程杀死，使用信号13(SIGPIPE)；

2.1.5管道文件的大小

ulimit -a
#查看操作系统对于关键资源的限制

​ open files表示单个进程能够打开文件的最大个数；管道单次写入最多是512b*8=4kb；管道的大小是64kb；

​ 为了保证数据的安全，需要保证数据的原子性；

2.1.6 匿名管道的应用

​ 1.命令行上用|实现管道通信；

​ 2.用管道文件实现进程池，即提前创建一批进程；

通过系统调用来向操作系统获取空间是有成本的，而使用池化技术可以提前获取一定的空间，不需要向操作系统频繁地进行申请，之前获取池子里的空间，提高了访问速度，减少了系统调用成本；

​ 进程池，一个父进程进行写，关闭读端0下标，剩下的子进程进行读取，关闭写端下标，但是由于子进程创建会拷贝父进程的地址空间，所以后面创建的子进程是可以看到多个写端的，而读端一直是下标0，要注意不能之关闭一个写端；

​ 比如父进程的地址空间下标1、2、3、4、5都是写端，对应有5个子进程，按照先后创建顺序，第一个子进程关闭了下标1写端，只有下标0读端，第二个子进程，读端为下标0，对应的写端下标为2，会将2关闭，但是由于继承了父进程的进程地址空间，所以可以看到1号写端，这样会导致1号写端文件的引用计数+1，但是却没有关闭下标为1的写端，可能会出现误操作；所以后面创建的子进程应该关闭所有写端；

​ 进程池释放三种方式，1.先把文件循环关闭，在循环关闭等待进程，对于最后一个子进程的5号写端引用计数为1，关闭时，此文件就真的关闭了，然后进程就会倒的释放，不会阻塞；2.倒的循环，先关闭最后一个文件，再等待子进程；3.保证每个管道只有一个读端和写端；

2.2命名管道

​ 不相关的进程想要进行通信则使用命名管道，使用FIFO文件完成工作；命名管道是一个特殊的文件类型；

​ 命名管道通过路径加文件名来看到同一份资源；

2.2.1创建和删除一个命名管道

mkfifo 文件名(myfifo)
#创建一个命名管道文件，文件类型为p，此文件并不会将数据刷新到磁盘，更多的是一种符号
echo "hello" 1>myfifo
cat 0<myfifo
#实现通信，注意此文件的大小一直是0；
unlink myfifo
#删除命名管道文件

2.2.2原理

​ 和匿名管道一样，两个不同的且没有任何血缘关系的进程打开同一个文件，会创建两个struct file结构，但是文件的属性、读写方法、内容还是只有一个，还是基于文件的通信；

​ 管道的实现就是不需要将通信数据进行刷盘，只是一个内存级文件；

2.2.3命名管道的使用

#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
//第一个参数是路径+文件名，第二个参数是打开方式；

2.3补充c语言可变参数

​ 使用可变参数是需要使用宏的；要注意可变参数的使用必须至少有一个具体的参数；

#include <stdarg.h>
void va_start(va_list ap, last);//宏
type va_arg(va_list ap, type);//宏
void va_end(va_list ap);//宏
void va_copy(va_list dest, va_list src);
//va_list其实就是char*的结构，再函数压栈的过程中，可以通过va_list来提取char数组中的元素；

int sum(int n, ...)
{
    // 不管是c/c++传参的时候都要压栈，形参从右往左进行实例化，但必须是得先定义一个va_list，
    // 它可以通过用char类型的指针来提取可变参数,va_list其实就是一个char * 类型
    va_list s;      // 是一个char *指针
    va_start(s, n); //是一个宏转换成了s=&n+1；
    // 定位n参数的位置,将s指向可变参数列表的第一个位置；如sum(3,1,2,3)，从右往左压参数，根据最后一个参数3，定位到参数列表的第一个位置，即第一个压入的第三个参数1；
    // std::cout << (*(int *)s) << std::endl;
   
    //完成了指向可变列表的第一个参数
    int sum = 0;
    while (n)
    {
        sum += va_arg(s, int); // 每次[*(int)]++；将第一个可变列表参数指定为int类型，解引用并++；
        n--;
    }
    va_end(s);//宏，本质就是将s置空
    return sum;
}

2.4补充日志函数

2.4.1获取时间和格式化时间接口

#include <time.h>
time_t time(time_t *t);//t是输出型参数，可以用来在外界接收时间戳，返回值是一个时间戳
struct tm *localtime(const time_t *timep);
//存储日期结构体
struct tm {
    int tm_sec;         /* seconds */
    int tm_min;         /* minutes */
    int tm_hour;        /* hours */
    int tm_mday;        /* day of the month */
    int tm_mon;         /* month */要+1
        int tm_year;        /* year */要加1900
            int tm_wday;        /* day of the week */
    int tm_yday;        /* day in the year */
    int tm_isdst;       /* daylight saving time */
};
	tm_sec    The number of seconds after  the  minute,  normally in the range 0 to 59, but can be up to 60 to allow for leap seconds.

    tm_min    The number of minutes after the  hour,  in  the range 0 to 59.

    tm_hour   The number of hours past midnight, in the range 0 to 23.

    tm_mday   The day of the month, in the range 1 to 31.

    tm_mon    The number of  months  since  January,  in  the range 0 to 11.

    tm_year   The number of years since 1900.
    int snprintf(char *str, size_t size, const char  *format, ...);

2.4.2日志函数的实现

#include <iostream>
#include <cstdarg>
#include <ctime>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#define SIZE 1024

#define Info 0
#define Debug 1
#define Warning 2
#define Fatal 4
#define Err 3

#define Screen 1
#define Onefile 2
#define Classfy 3 // 多个文件

#define LogFile "log.txt"

class Log
{
public:
    Log()
        : _printMethod(Screen), _path("./log/")
    {
    }
    void Enable(int Method)
    {
        _printMethod = Method;
    }
    std::string levelToString(int level)
    {
        switch (level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Warning:
            return "Warning";
        case Fatal:
            return "Fatal";
        case Err:
            return "Err";
        default:
            return "None";
        }
    }

    void printLog(int level, const std::string &logtxt)
    {
        switch (_printMethod)
        {
        case Screen:
            std::cout << logtxt << std::endl;
            break;
        case Onefile:
            printOnefile(LogFile, logtxt);
            break;
        case Classfy:
            printClassfy(level, logtxt);
            break;
        default:
            break;
        }
    }
    void printOnefile(const std::string &logname, const std::string &logtxt)
    {
        std::string _logname = _path + logname;
        int fd = open(_logname.c_str(), O_WRONLY | O_APPEND | O_CREAT, 0666);
        if (fd < 0)
        {
            return;
        }
        write(fd, logtxt.c_str(), logtxt.size());
        close(fd);
    }
    void printClassfy(int level, const std::string &logtxt)
    {
        std::string filename = LogFile;
        filename += '.';
        filename += levelToString(level);
        printOnefile(filename, logtxt);
    }
    void operator()(int level, const char *format, ...)
    {
        time_t t = time(nullptr);
        struct tm *currenttime = localtime((const time_t *)&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]",
                 levelToString(level).c_str(), currenttime->tm_year + 1900,
                 currenttime->tm_mon + 1, currenttime->tm_mday, currenttime->tm_hour, currenttime->tm_min, currenttime->tm_sec);
        va_list s;
        va_start(s, format);
        char rightbuffer[SIZE * 2];
        vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
        va_end(s);

        char logtxt[SIZE * 2];
        snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);

        printLog(level, logtxt);
        // printf("%s", logtxt); // 先将日志打印出来

        //printf("%d-%d-%d %d:%d:%d\n", currenttime->tm_year + 1900,\
           currenttime->tm_mon + 1, currenttime->tm_mday, currenttime->tm_hour, currenttime->tm_min, currenttime->tm_sec);
        // tm_year是从1900年开始，tm_mon的range是0~11
        // 日志格式默认部分+自定义部分
    }
    ~Log()
    {
    }

private:
    int _printMethod;
    std::string _path;
};