## commit message 规范

代码风格统一，代码提交信息的说明准确，那么在后期协作以及Bug处理时会更加方便，先来介绍推荐采用的commit规范吧，Commit message格式如下： `type(scope): subject` 注意冒号后面有空格，type用于说明commit的类别，只允许使用下面7个标识：

**type**：type用于说明commit的类别

* feat：新功能（feature）

* fix：修补bug

* docs：文档（documentation）

* style： 格式（不影响代码运行的变动）

* refactor：重构（即不是新增功能，也不是修改bug的代码变动）

* test：增加测试

* chore：构建过程或辅助工具的变动

如果type为feat和fix，则该commit将肯定出现在Change log之中。

**scope**：可选项，用于说明commit的影响范围

**subject**:：commit 目的的简短描述，不超过50个字符，且结尾不加句号



## Git 分支的规范

* master分支为主分支(保护分支)，不能直接在master上进行修改代码和提交；
* develop分支为测试分支，所以开发完成需要提交测试的功能合并到该分支；
* feature分支为开发分支，大家根据不同需求创建独立的功能分支，开发完成后合并到develop分支；
* fix分支为bug修复分支，需要根据实际情况对已发布的版本进行漏洞修复；

使用Git的一些规范

## 消息队列

消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法
每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值
消息队列也有管道一样的不足，就是**每个消息的最大长度是有上限的**（MSGMAX），每个消息队列的总的字节数是有上限的（MSGMNB），系统上消息队列的总数也有一个上限（MSGMNI）

**消息队列不提供同步与互斥**

**消息队列不提供同步与互斥**

**消息队列不提供同步与互斥**

![mark](https://img.zouchanglin.cn///20200201/rdHW6qDct3mF.png)



## IPC对象数据结构

IPC全称是：Inter Process Communication (进程间通信)
IPC的源码：/include/linux/ipc.h
**PS:这个链接可以下载到1.0版本的源码
https://mirrors.edge.kernel.org/pub/linux/kernel/v1.0/**

```c
struct ipc_perm
{
  key_t  key;
  ushort uid;   /* owner euid and egid */
  ushort gid;
  ushort cuid;  /* creator euid and egid */
  ushort cgid;
  ushort mode;  /* access modes see mode flags below */
  ushort seq;   /* sequence number */
};
```

消息队列结构源码：/include/linux/msg.h

```c
/* one msqid structure for each queue on the system */
struct msqid_ds {
    struct ipc_perm msg_perm;
    struct msg *msg_first;  /* first message on queue */
    struct msg *msg_last;   /* last message in queue */
    time_t msg_stime;       /* last msgsnd time */
    time_t msg_rtime;       /* last msgrcv time */
    time_t msg_ctime;       /* last change time */ 
    struct wait_queue *wwait;
    struct wait_queue *rwait;
    ushort msg_cbytes;      /* current number of bytes on queue */
    ushort msg_qnum;        /* number of messages in queue */
    ushort msg_qbytes;      /* max number of bytes on queue */
    ushort msg_lspid;       /* pid of last msgsnd */
    ushort msg_lrpid;       /* last receive pid */
};
```

![mark](https://img.zouchanglin.cn///20200201/1o4GMc90tHYA.png)

在管道的通信方式中，两个进程需要看到同一份资源那就是管道文件，具有亲缘关系的进程之间其实很容易使用匿名管道进行通信，没有亲缘关系的进程也可以使用文件名来识别同一块资源(管道)，**因为Linux下，同一个目录下不可能出现同名文件，根据这个道理，每个文件的路径+自身的文件名就会形成唯一的标识**，那么对于两个不相干的进程如何看到同一份消息队列呢？其实`ipc_perm`结构体的`key_t key`值解决了这个问题，可以把这个消息队列的唯一标识存储在`key_t key`中，这样只要是`key_t key`一致，那么看到的消息对列就是一致的！

## ftok

根据指定的路径和一个8位的整数来生成一个唯一的识别码

```c
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id)
```

`pathname`:指定的文件路径
`proj_id`:自己设定的序列号
`return`:唯一标识ID
The ftok() function uses the identity of the file named by the given pathname (which must refer to an existing, accessible file) and the least significant 8 bits of proj_id (which must be nonzero) to generate a key_t type System V IPC key, suitable for use with msgget(2),semget(2), or shmget(2).
The resulting value is the same for all pathnames that name the same file, when the same value of proj_id is used. The value returned should be different when the (simultaneously existing) files or the project IDs differ.
On success, the generated key_t value is returned. On failure -1 is returned, with errno indicating the error as for the stat(2) system call.
ftok()函数使用由给定路径名命名的文件的标识(必须引用现有的可访问文件)和proj_id的最低8位（必须非零）来生成key_t类型System V IPC密钥 ，适用于msgget，semget或shmget。
当使用相同的proj_id值时，对于命名同一文件的所有路径名，结果值是相同的。 当（同时存在的）文件或项目ID不同时，返回的值应该不同。
成功时，返回生成的key_t值。 失败时返回-1，errno指示stat系统调用的错误。

共享内存，信号量，消息队列都是通过共享文件的方式进行通信，但是这些共享文件的区分方式就是需要一个识别码，你可以理解为每个人都有自己的身份证号码一样，都是唯一的，简言之就是：ftok函数可以根据指定的路径和一个8位的整数来生成一个唯一的识别码，一般在UNIX中，通常是将文件的索引节点取出，然后在前面加上子序号就得到key_t的值。
**注意：ftok根据文件路径生成ID和文件的权限无关**

## msgget

用来创建和访问一个消息队列

```c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg)
```

`key`: 某个消息队列的名字
`msgflg`:由九个权限标志构成，用法和创建文件时使用的mode模式标志一致
`return`：成功返回一个非负整数，即该消息队列的标识码；失败返回-1

![mark](https://img.zouchanglin.cn///20200201/t5K4a2riMLgs.png)

关键点：
IPC_CREAT：如果内核中不存在键值与key相等的消息队列，则新建一个消息队列；如果存在这样的消息队列，返回此消息队列的标识符
IPC_CREAT|IPC_EXCL：如果内核中不存在键值与key相等的消息队列，则新建一个消息队列；如果存在这样的消息队列则报错

错误代码：
EACCES：指定的消息队列已存在，但调用进程没有权限访问它
EEXIST：key指定的消息队列已存在，而msgflg中同时指定IPC_CREAT和IPC_EXCL标志
ENOENT：key指定的消息队列不存在同时msgflg中没有指定IPC_CREAT标志
ENOMEM：需要建立消息队列，但内存不足
ENOSPC：需要建立消息队列，但已达到系统的限制

## msgctl

控制消息队列

```c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
```

`msqid`: 由msgget函数返回的消息队列标识码
`cmd`:是将要采取的动作,（有三个可取值）
`return`：成功返回0，失败返回-1

> **cmd:将要采取的动作，分别如下**

| 命令     | 说明                                                         |
| :------- | :----------------------------------------------------------- |
| IPC_STAT | 把msqid_ds结构中的数据设置为消息队列的当前关联值，获得msgid的消息队列头数据到buf中 |
| IPC_SET  | 在进程有足够权限的前提下，把消息队列的当前关联值设置为msqid_ds数据结构中给出的值，设置消息队列的属性，要设置的属性需先存储在buf中，可设置的属性包括：msg_perm.uid、msg_perm.gid、msg_perm.mode以及msg_qbytes |
| IPC_RMID | 删除消息队列                                                 |

错误代码：
EACCESS：参数cmd为IPC_STAT，确无权限读取该消息队列
EFAULT：参数buf指向无效的内存地址
EIDRM：标识符为msqid的消息队列已被删除
EINVAL：无效的参数cmd或msqid
EPERM：参数cmd为IPC_SET或IPC_RMID，却无足够的权限执行

## msgsnd函数

把一条消息添加到消息队列中

```c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
```

`msgid`: 由msgget函数返回的消息队列标识码
`msgp`:是一个指向结构体的指针，指针指向准备发送的消息

- msgp可以是任何类型的结构体，但第一个字段必须为long类型，即表明此发送消息的类型，msgrcv根据此接收消息

`msgsz`:是msgp指向的消息长度，这个长度不含保存消息类型的那个long int长整型
`msgflg`:控制着当前消息队列满或到达系统上限时将要发生的事情，

- 0：当消息队列满时，msgsnd将会阻塞，直到消息能写进消息队列
- IPC_NOWAIT：当消息队列已满的时候，msgsnd函数不等待立即返回
- IPC_NOERROR：若发送的消息大于size字节，则把该消息截断，截断部分将被丢弃，且不通知发送进程

`return`：成功返回0；失败返回-1
注意：消息结构必须小于系统规定的上限值；其次，必须以一个long int长整数开始，接收者函数将利用这个长整数确定消息的类型，消息结构参考形式如下：

```c
struct msgbuf {
	long mtype;
	char mtext[1];
}
```

msgsnd()解除阻塞的三个条件：
① 不满足消息队列满或个数满两个条件，即消息队列中有容纳该消息的空间。
② msqid代表的消息队列被删除。
③ 调用msgsnd函数的进程被信号中断。

## msgrcv

从标识符为msqid的消息队列读取消息并存于msgp中，读取后把此消息从消息队列中删除

```c
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
```

`msgid`: 由msgget函数返回的消息队列标识码
`msgp`:是一个指针，指针指向准备接收的消息，
`msgsz`:是msgp指向的消息长度，这个长度不含保存消息类型的那个long int长整型
`msgtype`:它可以实现接收优先级的简单形式
`msgflg`:控制着队列中没有相应类型的消息可供接收时将要发生的事

- 0: 阻塞式接收消息，没有该类型的消息msgrcv函数一直阻塞等待
- IPC_NOWAIT：如果没有返回条件的消息调用立即返回，此时错误码为ENOMSG
- IPC_EXCEPT：与msgtype配合使用返回队列中第一个类型不为msgtype的消息
- IPC_NOERROR：如果队列中满足条件的消息内容大于所请求的size字节，则把该消息截断，截断部分将被丢弃

`return`:成功返回实际放到接收缓冲区里去的字符个数，失败返回-1



msgtype=0返回队列第一条信息
msgtype>0返回队列第一条类型等于msgtype的消息　
msgtype<0返回队列第一条类型小于等于msgtype绝对值的消息，并且是满足条件的消息类型最小的消息

## ipcs、ipcrm

这是两个命令，ipcs:可以显示IPC资源，ipcrm用于手动删除IPC资源
管道虽然也可以用于进程间通信，但是管道的声明周期是随进程的，但是消息队列、信号量、共享内存的声明周期是随内核，需要我们自己调用函数或者命令手动清除，所以当每次使用消息队列的时候不要忘记删除IPC资源：

### ipcs

显示 IPC 设施的信息。
`ipcs [资源选项...] [输出选项]`
`ipcs -m|-q|-s -i `
选项：
-i, –id 打印由标识的资源的详细信息
-h, –help display this help
-V, –version display version

资源选项：
-m, –shmems 共享内存段
-q, –queues 消息队列
-s, –semaphores 信号量
-a, –all 全部(默认)
输出选项：
-t, –time 显示附加、脱离和更改时间
-p, –pid 显示创建者和最后操作者的 PID
-c, –creator 显示创建者和拥有者
-l, –limits 显示资源限制
-u, –summary 显示状态摘要
-h, –human 以易读格式显示大小
-b, –bytes 以字节数显示大小

### ipcrm

移除某个 IPC 资源。
ipcrm [选项]
`ipcrm shm|msg|sem ...`
选项：
-m, –shmem-id 按 id 号移除共享内存段
-M, –shmem-key <键> 按键值移除共享内存段
-q, –queue-id 按 id 号移除消息队列
-Q, –queue-key <键> 按键值移除消息队列
-s, –semaphore-id 按 id 号移除信号量
-S, –semaphore-key <键> 按键值移除信号量
-a, –all[=<shm|msg|sem>] (将指定类别中的)全部移除
-v, –verbose 解释正在进行的操作

方式一：使用ipcs -q命令查询IPC资源中消息队列的msqid，再使用ipcrm

![mark](https://img.zouchanglin.cn///20200201/lrKOvaHJ1fBe.png)

方式二：在代码中使用消息队列控制函数msgctl设置参数为IPC_RMID
下面是两个进程之间使用消息队列通信的代码：
comm.c

```c
#include "comm.h"

static int CommGetMsgQueue(int flag){
    key_t k = ftok(PATHNAME, PROJID);//失败返回-1
    if(k < 0){
        perror("ftok error");
        return -1;
    }

    int msgid = msgget(k, flag);

    if(msgid < 0){
        perror("msgget error");
    }
    return msgid;
}

//创建消息队列
int CreateMsgQueue(){
    return CommGetMsgQueue(IPC_CREAT|IPC_EXCL|0666);//附加权限
}

//打开消息队列
int OpenMsgQueue(){
    return CommGetMsgQueue(IPC_CREAT);
}

//发送消息
void SendMsg(int msgid, char msg[], int type){
    //准备要发出的数据
    struct msgbuf s_msg;
    s_msg.mtype = type;
    strcpy(s_msg.mtext, msg);

    if(msgsnd(msgid, (void*)&s_msg, sizeof(s_msg.mtext), 0) < 0){
        printf("msgsend error");
    }
}

//接受消息
void RecvMsg(int msgid, char msg[], int type){
    struct msgbuf _msg;
    //读取消息到_msg中
    if(msgrcv(msgid, (void*)&_msg, sizeof(_msg.mtext),type, 0) > 0){
        //把数据传出去
        strcpy(msg, _msg.mtext);
    }
}


//删除消息队列
void DestroyMsgQueue(int msgid){
    msgctl(msgid, IPC_RMID, NULL);
}
```

comm.h

```c
#ifndef INC_32_CODE_COMM_H
#define INC_32_CODE_COMM_H

#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <memory.h>
#include <unistd.h>

#define PATHNAME "/tmp"
#define PROJID 0x6666

#define SERVER_TYPE 1
#define CLIENT_TYPE 2

struct msgbuf{
    long mtype;
    char mtext[256];
};

//创建消息队列
int CreateMsgQueue();

//打开消息队列
int OpenMsgQueue();

//删除消息队列
void DestroyMsgQueue(int msgid);

//发送消息
void SendMsg(int msgid, char msg[], int type);

//接受消息
void RecvMsg(int msgid, char msg[], int type);

#endif //INC_32_CODE_COMM_H
```

client.c

```c
#include "comm.h"

int main(){

    int msgid = OpenMsgQueue();

    //接收其他进程（server）发的消息
    char msg[256];
    while(1){
        RecvMsg(msgid,msg,SERVER_TYPE);
        printf("RECV = %s\n", msg);
        sleep(1);
    }
    return 0;
}
```

server.c

```c
#include "comm.h"

int main(){
    int msgid = CreateMsgQueue();
    printf("msgid = %d\n",msgid);

    while(1){
        //发送消息到消息队列
        SendMsg(msgid, "hello,xpu", SERVER_TYPE);
        sleep(1);
    }

    SendMsg(msgid, "hello,xpu", SERVER_TYPE);
    sleep(1);
    SendMsg(msgid, "hello,xpu", SERVER_TYPE);
    sleep(1);
    SendMsg(msgid, "hello,xpu", SERVER_TYPE);
    sleep(1);
    SendMsg(msgid, "hello,xpu", SERVER_TYPE);
    sleep(1);
#if 0

    //自己接收自己发的消息
    char msg[256];
    RecvMsg(msgid,msg,SERVER_TYPE);
    printf("RECV = %s\n", msg);
    sleep(1);
    RecvMsg(msgid,msg,SERVER_TYPE);
    printf("RECV = %s\n", msg);
    sleep(1);
    RecvMsg(msgid,msg,SERVER_TYPE);
    printf("RECV = %s\n", msg);
    sleep(1);
    RecvMsg(msgid,msg,SERVER_TYPE);
    printf("RECV = %s\n", msg);
    sleep(1);
    RecvMsg(msgid,msg,SERVER_TYPE);
    printf("RECV = %s\n", msg);
    sleep(1);
#endif
    DestroyMsgQueue(msgid);
    return 0;
}
```

Linux进程通信之消息队列

**Linux进程间通信的基本思想是：让两个进程看到一份公共的资源！**

## Linux进程间通信的目的

- 数据传输：⼀个进程需要将它的数据发送给另⼀个进程
- 资源共享：多个进程之间共享同样的资源。
- 通知事件：⼀个进程需要向另⼀个或⼀组进程发送消息，通知它们发生了某种事件（如进程终止时要通知父进程）。
- 进程控制：有些进程希望完全控制另⼀个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变

## 通信方式之管道

管道是Unix中最古老的进程间通信的形式。
我们把从⼀个进程连接到另⼀个进程的⼀个数据流称为⼀个”管道”

- 管道是面向字节流的
- 管道的生命周期：与进程一致
- 管道只能用于单向通信
- 内核会对管道操作进行同步与互斥







接下来看看管道的使用：

![mark](https://img.zouchanglin.cn///20200201/RBhiiWDUdm70.png)

## 匿名管道

### pipe函数

功能：创建匿名管道

```c
#include <unistd.h>
int pipe(int pipefd[2]);
```

返回值：
On success, zero is returned. On error, -1 is returned, and errno is set appropriately.
成功返回0，失败返回错误代码！
参数说明：
pipe() creates a pipe, a unidirectional data channel that can be used for interprocess communication. The array pipefd is used to return two file descriptors referring to the ends of the pipe. pipefd[0] refers to the read end of the pipe. pipefd[1] refers to the write end of the pipe. Data written to the write end of the pipe is buffered by the kernel until it is read from the read end of the pipe.
pipe() 创建一个管道，一个可用于进程间通信的单向数据通道。该文件描述符数组用于返回引用管道末端的两个文件描述符。 pipefd [0]指的是管道的读端。 pipefd [1]指的是管道的写端。写入结束的数据管道由内核缓冲，直到从管道的读取端读取。

管道简单使用示例：从键盘读取数据，写⼊管道，读取管道，写到屏幕



```c
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char *argv[]) {
	int fds[2];
	char buf[100] = { 0 };
	size_t len;
	ssize_t r_len;
	

	if (pipe(fds) == -1) {
		perror("make pipe");
		exit(1);
	}

	//read from stdin
	while (fgets(buf, 100, stdin)) {
		len = strlen(buf);
		//write to pipe
		if (write(fds[1], buf, len) != len) {
			perror("write to pipe");
			break;
		}
		memset(buf, 0, 100);

		//read from pipe
		if ((r_len = read(fds[0], buf, (size_t)100)) == -1) {
			perror("read form pipe");
			break;
		}

		//write to stdout
		if (write(1, buf, len) != len) {
			perror("write to stdout");
			break;
		}
	}
		
	return 0;
}
```

### 亲缘关系进程直接的通信

上面的示例演示了管道的基本使用方式，但是不包含进程之间的通信！接下来看看父子进程之间的通信：

![mark](https://img.zouchanglin.cn///20200201/ln71rk9fc6Sy.png)

从文件描述符理解管道：

![mark](https://img.zouchanglin.cn///20200201/eJCO0T3Yzevi.png)

从内核角度理解管道：

![mark](https://img.zouchanglin.cn///20200201/RYlSkircsikU.png)

所以可以看到，管道其实也是文件，在Linux下一切皆文件！

```c
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>

int main(){
    int pipefd[2];
    
    //创建一个匿名管道，失败直接退出
    if(pipe(pipefd) == -1){
        perror("pipe");
        exit(EXIT_FAILURE);
    }

    pid_t pid;
    pid = fork();
    if(pid == -1){
        perror("pipe");
        exit(EXIT_FAILURE);
    }

	 //父进程
    if(pid == 0){
        close(pipefd[0]);
        write(pipefd[1], "hello", 5);
        close(pipefd[1]);
        exit(EXIT_SUCCESS);
    }

    close(pipefd[1]);

    char buf[10] = {0};
    read(pipefd[0], buf, 10);
    printf("buf = %s\n", buf);

    return 0;
}
```

### 管道的读写规则

- 当没有数据可读时
  - O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止
  - O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN
- 当管道满的时候
  - O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
  - O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
- 如果所有管道写端对应的文件描述符被关闭，则read返回0
  如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出，这个不难理解，因为没有人从管道读信息时向管道写入东西是没有意义的，这是一种资源的浪费，所以管道读端对应的文件描述符被关闭时其实应该结束掉write进程；
- 当要写入的数据量不大于`PIPE_BUF`时，linux将保证写入的原子性。
- 当要写入的数据量大于`PIPE_BUF`时，linux将不再保证写入的原子性。

### 管道的特点

- 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
- 管道提供流式服务
- 一般而言，进程退出，管道释放，所以管道的生命周期随进程
- 一般而言，内核会对管道操作进行同步与互斥
- 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道

## 命名管道

管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。
如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。命名管道是一种特殊类型的文件!
接下来使用一个脚本来演示用管道进行通信：

![]( https://img.zouchanglin.cn/EsNpWTx35vd.gif )

如果此时我们关闭读端，那么写端就会退出，道理很简单，和匿名管道一样，如果读端都关闭了那么此时如果写端还在写的话其实是一种资源浪费，于是操作系统直接向写端发信号终止写端进程！

### 匿名管道和命名管道之间的区别

- 匿名管道由pipe函数创建并打开，命名管道由mkfifo函数创建，打开用open函数
- FIFO(命名管道)与pipe(匿名管道)之间唯一的区别在它们创建与打开的方式不同

### 命名管道的打开规则

如果当前打开操作是为读而打开FIFO时：

- O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO
- O_NONBLOCK enable：立刻返回失败，错误码为ENXIO
如果当前打开操作是为写而打开FIFO时：
- O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO
- O_NONBLOCK enable：立刻返回失败，错误码为ENXIO

接下来是一个模拟客户端和服务器端通信的示例：

![mark](https://img.zouchanglin.cn///20200201/x5DQGY3VY5pA.gif)

client.c

```c
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <memory.h>

#define FIFONAME "mypipe"

int main() {
    //创建一个命名管道
    mkfifo(FIFONAME, 0664);

    //打开这个命名管道
    int fd = open(FIFONAME, O_WRONLY);

    if(fd < 0){
        return 1;
    }

    char buf[1024];
    while(1){
        printf("Please Enter Your Message To Server# ");
        fflush(stdout);
        //从标准输入读取信息
        ssize_t s = read(0,buf,sizeof(buf));
        buf[s-1] = 0;//覆盖掉之前的回车换行
        
        //向管道写
        write(fd,buf,strlen(buf));
    }
    close(fd);
    return 0;
}
```

server.c

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

#define FIFONAME "mypipe"

int main() {
    //创建一个命名管道
    mkfifo(FIFONAME, 0664);

    //打开这个命名管道
    int fd = open(FIFONAME, O_RDONLY);

    if(fd < 0){
        return 1;
    }

    char buf[1024];
    while(1){
        ssize_t s = read(fd, buf, sizeof(buf)-1);
        if(s > 0){
            //读取成功
            buf[s] = 0;
            printf("client# %s\n", buf);
        }else if(s == 0){
            //写端把文件描述符关闭
            printf("client quit！server quit too!\n");
            break;
        }else{
            break;
        }
    }
    return 0;
}
```

Bash中的管道是采用匿名管道的方式进行通信，由于匿名管道只能用于在具有亲缘关系之间通信，但是由Bash开启的进程之间是属于兄弟关系，自然就可以通过匿名管道进行通信，多个进程(多个管道)的情况下只要每个进程关闭或打开相应的读写端，形成链式数据结构便可以进行通信了(再次佩写服Bash的大佬)

Linux进程通信之管道

## Git基本概念

![mark](https://img.zouchanglin.cn///20200201/jambXWN0Amn2.png)

Workspace：工作区
Index / Stage：暂存区
Repository：仓库区（或本地仓库）
Remote：远程仓库





## Git常用命令

初始化一个仓库：`git init`
添加文件：`git add 文件名`
添加所有文件：`git add *`
提交到本地仓库： `git commit -m "提交说明"`
查看仓库的状态：`git status`
查看发生更改的文件的具体改变位置：`git diff 文件名`
查看我们提交历史（以便确定要回退到哪个版本。）：`git log`
查看我们提交历史(单行显示)：`git log--pretty=oneline`
回退到上一个版本：`git reset --hard HEAD^`
回退到上上一个版本：`git reset --hard HEAD^^`
回退到100个之前的版本：`git reset --hard HEAD~100`
回退到指定版本：`git reset --hard 版本号`（版本号也就是git log–pretty=oneline前面显示的id，只需要记住前几位即可）
查看命令历史（用来重返未来）：`git reflog`
用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”：`git checkout`
删除一个文件：`git rm 文件名`

提交到远程仓库：
1、在远程创建一个与本地仓库名一致的仓库
2、git remote add origin [git@github.com](mailto:git@github.com):用户名/仓库名.git
3、git push -u origin master

## 初次使用配置Git

第一步：设置用户名和邮箱，并且生成秘钥
不要密码的话直接一直Enter就行！

```bash
git config --global user.name "你的名字"
git config --global user.email "你的邮箱"
ssh-keygen -t rsa -C "你的邮箱"
```

![mark](https://img.zouchanglin.cn///20200201/EkvwxL6c2N1v.png)

第二步：到git仓库，添加秘钥
如果你没有改变秘钥的生成路径，那么通过家目录的`.ssh`下通过cat命令应该可以看到生成的秘钥，添加到GitHub（这里以Github为例）的秘钥中！

![mark](https://img.zouchanglin.cn///20200201/gSMFwmRFovC3.png)

![mark](https://img.zouchanglin.cn///20200201/E3X4jDpJTqqL.png)

第三步: `ssh -T git@github.com` 测试一下通不通，不通就是`ssh-agent -s` `ssh-add ~/.ssh/id_rsa`操作这两步

第四步：把代码clone下来，使用`git clone` 命令将仓库拷贝下来！ 

![mark](https://img.zouchanglin.cn///20200201/khCSE2WKSSf1.png)

## 分类操作的命令

### 新建代码库

- 在当前目录新建一个Git代码库`git init`
- 新建一个目录，将其初始化为Git代码库`git init [project-name]`
- 下载一个项目和它的整个代码历史`git clone [url]`



### 配置

- Git的设置文件为 **.gitconfig** ，它可以在用户主目录下（全局配置），也可以在项目目录下（项目配置）
- 显示当前的Git配置`git config --list`
- 编辑Git配置文件`git config -e [--global]`
- 设置提交代码时的用户信息
  - `git config [--global] user.name "[name]"`
  - `git config [--global] user.email "[email address]"`





### 增加/删除文件

- 添加指定文件到暂存区`git add [file1] [file2] ...`
- 添加指定目录到暂存区，包括子目录`git add [dir]`
- 添加当前目录的所有文件到暂存区`git add .`
- 删除工作区文件，并且将这次删除放入暂存区`git rm [file1] [file2] ...`
- 停止追踪指定文件，但该文件会保留在工作区`git rm --cached [file]`
- 改名文件，并且将这个改名放入暂存区`git mv [file-original] [file-renamed]`



### 代码提交

- 提交暂存区到仓库区`git commit -m [message]`
- 提交暂存区的指定文件到仓库区`git commit [file1] [file2] ... -m [message]`
- 提交工作区自上次commit之后的变化，直接到仓库区`git commit -a`
- 提交时显示所有diff信息`git commit -v`
  *使用一次新的commit，替代上一次提交如果代码没有任何新变化，则用来改写上一次commit的提交信息`git commit --amend -m [message]`
- 重做上一次commit，并包括指定文件的新变化`git commit --amend ...`





### 分支

- 列出所有本地分支`git branch`
- 列出所有远程分支`git branch -r`
- 列出所有本地分支和远程分支`git branch -a`
- 新建一个分支，但依然停留在当前分支`git branch [branch-name]`
- 新建一个分支，并切换到该分支`git checkout -b [branch]`
- 新建一个分支，指向指定commit`git branch [branch] [commit]`
- 新建一个分支，与指定的远程分支建立追踪关系`git branch --track [branch] [remote-branch]`
- 切换到指定分支，并更新工作区`git checkout [branch-name]`
- 建立追踪关系，在现有分支与指定的远程分支之间`git branch --set-upstream [branch] [remote-branch]`
- 合并指定分支到当前分支`git merge [branch]`
- 选择一个commit，合并进当前分支`git cherry-pick [commit]`
- 删除分支`git branch -d [branch-name]`
- 删除远程分支`git push origin --delete`、`git branch -dr`





### 标签

- 列出所有tag `git tag`
- 新建一个tag在当前commit`git tag [tag]`
- 新建一个tag在指定commit`git tag [tag] [commit]`
- 查看tag信息`git show [tag]`
- 提交指定tag`git push [remote] [tag]`
- 提交所有tag`git push [remote] --tags`
- 新建一个分支，指向某个tag`git checkout -b [branch] [tag]`





### 查看信息

- 显示有变更的文件`git status`
- 显示当前分支的版本历史`git log`
- 显示commit历史，以及每次commit发生变更的文件`git log --stat`
- 显示某个文件的版本历史，包括文件改名`git log --follow [file]`、`git whatchanged [file]`
- 显示指定文件相关的每一次diff`git log -p [file]`
- 显示指定文件是什么人在什么时间修改过`git blame [file]`
- 显示暂存区和工作区的差异`git diff`
- 显示暂存区和上一个commit的差异`git diff --cached []`
- 显示工作区与当前分支最新commit之间的差异`git diff HEAD`
- 显示两次提交之间的差异`git diff [first-branch]...[second-branch]`
- 显示某次提交的元数据和内容变化`git show [commit]`
- 显示某次提交发生变化的文件`git show --name-only [commit]`
- 显示某次提交时，某个文件的内容`git show [commit]:[filename]`

* 显示当前分支的最近几次提交`git reflog` 



### 远程同步

- 下载远程仓库的所有变动`git fetch [remote]`
- 显示所有远程仓库`git remote -v`
- 显示某个远程仓库的信息`git remote show [remote]`
- 增加一个新的远程仓库，并命名`git remote add [shortname] [url]`
- 取回远程仓库的变化，并与本地分支合并`git pull [remote] [branch]`
- 上传本地指定分支到远程仓库`git push [remote] [branch]`
- 强行推送当前分支到远程仓库，即使有冲突`git push [remote] --force`
- 推送所有分支到远程仓库`git push [remote] --all`





### 撤销

- 恢复暂存区的指定文件到工作区`git checkout [file]`
- 恢复某个commit的指定文件到工作区`git checkout [commit] [file]`
- 恢复上一个commit的所有文件到工作区`git checkout .`
- 重置暂存区的指定文件，与上一次commit保持一致，但工作区不变`git reset [file]`
- 重置暂存区与工作区，与上一次commit保持一致`git reset --hard`
- 重置当前分支的指针为指定commit，同时重置暂存区，但工作区不变`git reset [commit]`
- 重置当前分支的HEAD为指定commit，同时重置暂存区和工作区，与指定commit一致`git reset --hard [commit]`
- 重置当前HEAD为指定commit，但保持暂存区和工作区不变`git reset --keep [commit]`
- 新建一个commit，用来撤销指定commit后者的所有变化都将被前者抵消，并且应用到当前分支`git revert [commit]`



### 其他

- 生成一个可供发布的压缩包`git archive`
- 备份当前工作区的内容`git stash`
- 从Git栈中读取最近一次保存的内容，恢复工作区的相关内容`git stash pop`
- 显示Git栈内的所有备份`git stash list`
- 清空Git栈`git stash clear`





## 常用的命令图

![mark](https://img.zouchanglin.cn///20200201/vYjfBcoQ9Du0.png)

Git基本使用方法

## 内存管理的形式

- 栈： 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的,当方法和语句块一结束，空间马上释放
- 内存映射段：是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信
- 堆：堆用于程序运行时动态内存分配，堆是可以上增长的，存放的是成员变量，随着对象而产生，随对象销毁而销毁
- 数据段：存储全局数据和静态数据
- 代码段：可执行的代码/只读常量





## malloc/calloc/realloc函数

```c
#include <stdlib.h>

void *malloc(size_t size);
void free(void *ptr);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);
```

The malloc() function allocates size bytes and returns a pointer to the allocated memory. The memory is not initialized.
If size is 0, then malloc() returns either NULL, or a unique pointer value that can later be successfully passed to free().

The free() function frees the memory space pointed to by ptr, which must have been returned by a previous call to malloc(),calloc() or realloc(). Otherwise, or if free(ptr) has already been called before, undefined behavior occurs. If ptr is NULL, no operation is performed.

The calloc() function allocates memory for an array of nmemb elements of size bytes each and returns a pointer to the allocated memory. The memory is set to zero. If nmemb or size is 0, then calloc() returns either NULL, or a unique pointer value that can later be successfully passed to free().

The realloc() function changes the size of the memory block pointed to by ptr to size bytes. The contents will be unchanged in the range from the start of the region up to the minimum of the old and new sizes. If the new size is larger than the old size, the added memory will not be initialized. If ptr is NULL, then the call is equivalent to malloc(size), for all values of size; if size is equal to zero, and ptr is not NULL, then the call is equivalent to free(ptr). Unless ptr is NULL, it must have been returned by an earlier call to malloc(), calloc() or realloc(). If the area pointed to was moved, a free(ptr) is done.

malloc()函数分配指定大小字节并返回指向已分配内存的指针。内存未初始化。
如果size为0，则malloc()返回NULL或一个以后可以成功传递给free()的唯一指针值。

free()函数释放ptr指向的内存空间，该内存空间必须由之前调用malloc()，calloc()或realloc()返回。否则，或者如果之前已经调用了free(ptr)，则会发生未定义的行为。如果ptr为NULL，则不执行任何操作。

calloc()函数为每个大小为nmemb字节的元素数组分配内存，并返回指向该区域的指针，存储内容设置为零。如果nmemb或size为0，则calloc()返回NULL或一个以后可以成功传递给free()的唯一指针值。

realloc()函数将ptr指向的内存块的大小更改为size字节。内容将在从区域的开始到新旧尺寸的最小范围内保持不变。如果新大小大于旧的大小，则不会初始化添加的内存。如果ptr为NULL，则对于所有size值，调用等效于malloc(size)；如果size等于零，并且ptr不为NULL，则调用等效于free(ptr)。除非ptr为NULL，否则必须由之前调用malloc()，calloc()或realloc()返回。如果指向的区域被移动，则free(ptr)。

## new/delete关键字

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理

### new/delete操作基本数据类型

```c
#include<iostream>

using namespace std;

int main(){

	int *ptr = new int;
	int *ptr2 = new int(1);

	//cout << *ptr << endl;
	//cout << *ptr2 << endl;


	//int *arr = new int[3]; //OK 但是没有初始化
	//int *arr = new int[3]{}; //OK 初始化为全0
	//int *arr = new int[3]{1, 2, 3}; //OK 指定内容初始化
	//int *arr = new int[]{1, 2, 3}; //OK 指定内容初始化
	int *arr = new int[3]{1, 2}; //OK 制定部分内容初始化
	//int *arr = new int[3]{1, 2, 3, 4};//Error 指定个数与实际不符合

	for (int i = 0; i < 3;i++){
		cout << arr[i] << endl;
	}
	delete[] arr;
	return 0;
}
```

### new/delete操作类

```cpp
#include<iostream>
#include <stdlib.h>

using namespace std;

class Demo{
public:
	Demo(){
		cout << "构造函数" << endl;
	}

	~Demo(){
		cout << "析构函数" << endl;
	}
};
int main(){
	Demo *pd = (Demo*)malloc(sizeof(Demo));
	free(pd);
	pd = NULL;

	cout << endl;
	Demo *pd2 = new Demo();
	delete pd2;
	

	cout << endl;
	Demo *pd_arr = new Demo[10];
	delete[] pd_arr;
	return 0;
}
```

![mark](https://img.zouchanglin.cn///20200201/XoStABwY87q9.png)

 注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。 

## malloc/free 与 new/delete区别

- **malloc/free和new/delete的共同点是：**
  - 都是从堆上申请空间，并且需要用户手动释放。
- **malloc/free和new/delete的不同点是：**
  - malloc和free是函数，new和delete是操作符
  - malloc申请的空间不能初始化，new可以初始化
  - malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
  - malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
  - malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
  - malloc/free只能申请内置类型的空间，不能申请自定义类型的空间，因为其不会调用构造与析构函数， 而new可以，new在申请空间后会调用构造函数完成对象的构造，delete在释放空间前会调用析构函数 完成空间中资源的清理
  - malloc申请的空间一定在堆上，new不一定，因为operator new函数可以重新实现 （new的空间可能在哪呢？）
  - new/delete比malloc和free的效率稍微低点，因为new/delete的底层封装了malloc/free



## operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

```cpp
/* 
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回
申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void *p;
	while ((p = malloc(size)) == 0)
	if (_callnewh(size) == 0)
	{
		// report no memory
		static const std::bad_alloc nomem;
		_RAISE(nomem);
	}
	return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void *pUserData)
{
	_CrtMemBlockHeader * pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */

	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}
```

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
注意：operator new和operator delete用户也可以自己实现，用户实现时即可实现成全局函数，也可实现成类的成员函数，但是一般情况下不需要实现，除非有特殊需求。

### operator new/operator delete与malloc/delete

new会调用构造方法，delete会调用析构函数
operator new 与 malloc 用法是一样的，不会调用构造函数
operator new 实际上就是malloc + 失败抛出异常
operator delete 与 free 用法是一样的，不会调用构造与析构函数
operator delete 实际上就是free + 失败抛出异常

## new和delete的实现原理

### 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

### 自定义类型

**new的原理**

1. 调用`operator new`函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造

**delete的原理**

1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用`operator delete`函数释放对象的空间

**new T[N]的原理**

1. 调用`operator new[]` 函数，在`operator new[]`中实际调用`operator new`函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数

**delete[]的原理**

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用`operator delete[]`释放空间，实际在`operator delete[]`中调用`operator delete`来释放空间

## 定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：



```cpp
new (place_address) type
//或者
new (place_address) type(initializer-list)
```

 place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。 

```cpp
#include <iostream>

class Demo{
public:
	Demo(){
		std::cout << "构造函数" << std::endl;
	}
};
int main(){
	//pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	Demo *p = (Demo*)malloc(sizeof(Demo));
	
	new(p)Demo;// 注意：如果Demo类的构造函数有参数时，此处需要传参

	delete p;
	return 0;
}
```



## 如何设计只能在堆/栈上创建的类

### 只能在堆上创建的类

1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建



```cpp
class HeapOnly{
public:
	static HeapOnly* CreatInstance(){
		  return new HeapOnly;
	}
private:
	HeapOnly(){}
	// 防拷贝
	HeapOnly(const HeapOnly&);
};
```



### 只能在栈上创建的类

只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，即屏蔽掉operator new和定位new表达式，注意：屏蔽了operator new，实际也将定位new屏蔽掉

```cpp
class StackOnly{
public:
	StackOnly(){}
private:
	void* operator new(size_t size) = delete;
	void operator delete(void *p) = delete;
};
```

## 设计模式之单例模式

一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享！

### 饿汉式单例模式

在程序初始化的时候就会创造出对象！

```cpp
class Singleton{
public:
	Singleton* GetInstance(){
		return &instance;
	}
private:
	Singleton(){}
	Singleton(const Singleton& other) = delete;
	Singleton& operator=(const Singleton& other) = delete;
	static Singleton instance;
};

Singleton Singleton::instance;// 在程序入口之前就完成单例对象的初始化
```

### 懒汉式单例模式

有时使用饿汉模式会导致程序启动时间变长，所以还有这种懒汉式单例模式来解决这个问题！

```cpp
#include <iostream>
#include <mutex>

class Singleton{
public:
	static Singleton* GetInstance(){
		// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
		if (m_pInstance == nullptr){
			m_mutex.lock();
			if (m_pInstance == nullptr){
				m_pInstance = new Singleton();
			}
			m_mutex.unlock();
		}
		return m_pInstance;
	}
	// 实现一个内嵌垃圾回收类
	class Recycle {
	public:
		~Recycle(){
			if (Singleton::m_pInstance)
				delete Singleton::m_pInstance;
		}
	};

	// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
	static Recycle recycle;
private:
	//构造函数私有
	Singleton(){}

	//防止拷贝
	Singleton(const Singleton& other) = delete;
	Singleton& operator=(const Singleton& other) = delete;

	static Singleton* m_pInstance; // 单例对象指针
	static std::mutex m_mutex;
};
Singleton* Singleton::m_pInstance = nullptr;
std::mutex Singleton::m_mutex;
Singleton::Recycle recycle;
```