Linux高性能网络编程十谈 | 多进程和多线程

在Linux网络编程中，我们应该见过很多网络框架或者server，有多进程的处理方式，也有多线程处理方式，孰好孰坏并没有可比性，首先选择多进程还是多线程我们需要考虑业务场景，其次结合当前部署环境，是云原生还是传统的IDC等，最后考虑可维护性，其具体的对比在第三部分具体会展开说。

第一部分：多进程

1、创建一个进程

#include 
pid_t fork(void);
// 返回值：子进程返回0，父进程返回子进程的pid，出错返回-1。

上面是一个创建进程的函数，那执行当前函数内核会做哪些事情呢?

(1)如果需要创建进程需要调用fork，进程调用fork，当控制转移到内核中的fork代码;

(2)内核做分配新的内存块和内核数据给子进程;

(3)内核将父进程部分数据结构内容拷贝进子进程，有一部分使用写时复制(copy on write)和父进程共享;

(4)添加子进程到系统进程列表中，同时父进程打开的文件描述符默认在子进程也会打开，且描述符引用计数加1;

(5)fork返回，内核调度器开始调度，因此fork之后，变成两个执行流;

2、进程的生成周期

进程创建子进程，当子进程结束以后会出现两种情况。

(1)如果父进程还在，子进程退出到父进程读取状态之前，这段时间为僵尸态，之后父进程可以调用以下函数等待：

#include 
#include 

pid_t wait(int *stat_loc);
pid_t waitpid(pid_t pid, int *stat_loc, int options);

// 代码样例
...
pid_t pid;
int stat;
while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) { // 非阻塞等待
    ...
}
...

(2)如果父进程不在，此时子进程会被init进程接管，并等待结束，如果此时子进程一直不退出，就会一直占用内核资源;

3、进程间通讯

在多进程编程模式中，各个进程不是孤立的，需要处理进程间通讯(IPC)，如果您已经有所了解可以一起温故。

(1)管道

管道通讯方式在前面已经讲过，通过pipe系统函数创建fd[0]和fd[1]，其中两个句柄就可以提供给父进程和子进程写入或者读出数据。

(2)信号量

信号量是为了解决访问临界区提供的一种特殊变量，支持两种操作：等待和信号，也就是对应P(进入临界区)，V(退出临界区);

假设现在有信号量SV，其执行：

• P(SV)，如果SV > 0，SV将减1;如果SV == 0，挂起的当前进程;
• V(SV)，如果有等待SV的进程则唤醒，如果没有则SV将加1;

Linux系统API如下：

#include 

int semget(key_t key, int nums, int sem_flags);
int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);
int semctl(int sem_id, int sem_num, int command, ...);

semget创建信号量，semop操作信号量，对应PV操作，semctl允许对信号量直接控制，为了方便大家理解，在此给一段代码。

...
// op == -1:执行P操作，op == 1:执行V操作
void pv(int sem_id, int op) {
    struct sembuf sem;
    sem.sem_num = 0;
    sem.sem_op = op;
    sem,sem_flg = SEM_UNDO;
    semop(sem_id, &sem, 1);
}

int main(...) {
    int sem_id = semget(IPC_PRIVATE, 1, 0666);
    ...
    pid_t pid = fork();
    if (id == 0) {
        ... 
        pv(sem_id, -1); // 执行P操作
        ...
        pv(sem_id, 1); // 执行V操作
        ...
    } else {
        ... 
        pv(sem_id, -1);
        ...
        pv(sem_id, 1);
        ...
    }
}

(3)共享内存

共享内存是在有些场景下，父进程和子进程需要读写大块的数据，因此Linux系统提供了shmget，shmat，shmdt，shmctl四个系统调用。

#include 

int shmget(key_t key, size_t size, int shmflg); 
void* shmat(int shm_id, const void *shm_addr, int shmflg);
int shmdt(const void* shm_addr);
int shmctl(int shm_id, int command, struct shmid_ds* buf);

int shm_open(const char * name, int oflag, mode_t mode);
int shm_unlink(const char * name);

shmget创建共享内存或者获取已存在的共享内存，key标识全局唯一共享内存，size为设置共享内存大小，shmflg设置的一些宏;

shmat共享内存被创建以后，不能直接访问，需要关联到进程的地址空间中，可以设置shm_addr = NULL由操作系统选择;

shm_open和open调用类似，是POSIX方法，创建一个共享内存对象，返回句柄与mmap调用;

shm_unlink删除共享内存标记;

为了方便大家理解，在此给一段代码：

...
shmfd = shm_open("xxxx", O_CREAT | O_RDWR, 0666);
share_mem = (char *)mmap(NULL, BUFFER_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
...

注意：共享内存需要考虑多写多读的问题，如果多个进程写，需要加锁处理。

(4)消息队列

#include 

int msgget(key_t key, int msgflg);
int msgsnd(int msgid, const void * msg_ptr, size_t msg_size, int msgflg);
int msgrcv(int msgid, void * msg_ptr, size_t msg_sz, long int msgtype, int msgflg);
int msgctl(int msgid, int command, struct msgid_ds * buf);

msgget创建消息队列，key标识全局唯一，msgflg和其他IPC的参数类似;

msgsnd和msgrcv是发送和写入消息类型的数据;

为了方便大家理解，在此给一段代码：

...

struct msg_buf
{
    long int msg_type;
    char text[BUFSIZ];
};
 
int main(int argc, char **argv)
{
    int msgid = -1;
    struct msg_buf data;
    long int msgtype = 0;
 
    // 建立消息队列
    msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
    ...
 
    // 从队列中获取消息
    while (1)
    {
        if (msgrcv(msgid, (void *)&data, BUFSIZ, msgtype, 0) == -1)
        {
            // ...
        }
        // 遇到end结束
        if (strncmp(data.text, "end", 3) == 0)
        {
            break;
        }
    }
    // 删除消息队列
    if (msgctl(msgid, IPC_RMID, 0) == -1)
    {
        ...
    }
    ...
}

(5)UNIX域

除了以上的通用的IPC，socket的UNIX域也可以作为进程间通讯，比如使用socket(AF_UNIX, SOCK_STREAM,
0)，或socketpair系统调用，或父进程创建一个127.0.0.1环回接口socket server，子进程通过socket client访问。

4、如何在网络编程中使用多进程

在多进程的网络编程中，实现方式有很多，但是总体还是围绕两条线，其一如何将新建连接分发给子进程，其二如何将数据/信号传给子进程，并监控子进程，下图是其实现方式之一(由于实现细节很多，后续会将实现代码开源到github)：

多进程

(1)首先为了性能考虑，进程池是必须的，通过线程池不需要频繁创建和销毁进程;

(2)其次主进程accept对应的新连接，考虑各个进程之间负载均衡，将新连接通过随机算法分发给子进程;

(3)分发方式可以通过管道，共享内存，消息队列等方式告知子进程，也可以传递数据信息;

(4)子进程收到新连接的句柄，就可以通过内部的epoll监听IO事件，从而完成send和recv;

第二部分：多线程

1、概述

在Linux中，线程是轻量级进程，运行在内核空间，由内核调度，最开始的线程库是linuxThreads，但是linuxThreads不符合POSIX标准，后来出现了NGPT和NPTL，其采用的线程模型不一样，所以性能有差异，性能由快到慢是：NPTL > NGPT > linuxThreads。

其中线程的模型分为三种：

• 多对一(M:1)的用户级线程模型;
• 一对一(1:1)的内核级线程模型：如linuxThreads和NPTL;
• 多对多(M:N)的两极线程模型：如NGPT;

现在Linux的2.6内核版本开始，默认使用NPTL线程库(1:1的线程模型)，对比linuxThreads有如下优势：

• 内核线程不再是一个进程，因此避免用进程模拟线程导致的语义问题;
• 摒弃了管理线程，终止线程和回收线程等工作由内核完成;
• 一个进程中的线程可以运行在不同的CPU上，可以充分利用多处理器系统;
• 线程的同步由内核完成，隶属于不同的进程的线程之间也可以共享互斥锁，因此可以实现跨进程的线程同步;

2、线程API

#include 
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
void pthread_exit(void *retval);
int pthread_join(pthread_t thread, void **retval);
int pthread_cancel(pthread_t thread);
int pthread_detach(pthread_t thread);
pthread_t pthread_self();

(1)pthread_create创建线程，thread表示线程ID，attr表示设置线程属性，另外传递线程处理函数start_routine和参数arg;

(2)pthread_exit线程退出，可以在start_routine执行完成以后调用;

(3)pthread_join是等待线程结束，调用成功返回0，否则返回错误;

(4)pthread_cancel异常终止一个线程;

(5)pthread_detach把指定的线程转变为脱离状态，线程有两种属性，一种是joinable，一种是detached，当一个joinable线程终止时，它的线程ID和退出状态将留存到另一个线程对它调用pthread_join，调用前线程的资源不会释放，而脱离detached线程终止时，资源会立刻释放;

(6)pthread_self获取当前线程ID;

为了方便大家理解，在此给一段代码(使用c++11语法，底层是以上API的封装)：

#include

#include

#include

void func(void *arg)

{

    std::cout