TinyWebServer项目笔记——02 半同步半反应堆线程池

目录

1.基础知识

（1）服务器编程基本框架

（2）五种I/O模型

（3）事件处理模式

（4）并发编程模式

（5）半同步/半反应堆

（6）线程池

（7）静态成员变量与静态成员函数

（8）pthread_create与this指针陷阱

2.线程池分析

（1）线程池类定义

（2）线程池创建与回收

（3）向请求队列中添加任务

（4）线程处理函数

（5）run执行任务

---

1.基础知识

（1）服务器编程基本框架

        主要由I/O单元、逻辑单元和网络存储单元组成。其中每个单元之间通过请求队列进行通信，从而协同完成任务。

        I/O单元用于处理客户端连接、读写网络数据；逻辑单元用于处理业务逻辑的线程；网络存储单元指本地数据库和文件等。

（2）五种I/O模型

        1.阻塞I/O：调用某个函数，会一直等待，直到函数返回。

                优点：简单易用，编程模型直观。

                缺点：效率低，尤其在高并发情况下，浪费CPU资源。

                适合场景：低并发、简单的应用。

        2.非阻塞I/O：非阻塞等待，每隔一段时间会检查是否就绪。没有则立即返回一个错误，然后去执行其他部分。

                优点：能同时处理多个I/O操作，提高利用率。

                缺点：轮询会消耗大量CPU资源，编程复杂度较高。

                适合场景：同时处理多个I/O操作，但对性能不高的场景。

        3.I/O多路复用：使用系统调用（如select、poll）同时监控多个文件描述符。当某个文件描述符就绪时，系统调用返回，程序处理对应的I/O操作。

                优点：高效处理大量并发连接，减少资源消耗。

                缺点：编程复杂度高，需要处理多个文件描述符的状态。

                适合场景：高并发服务器。

        4.信号驱动I/O：程序通过系统调用注册一个信号处理函数。当I/O操作就绪时，内核会发送一个信号通知程序。

                优点：不需要轮询，减少CPU消耗。

                缺点：信号处理函数中可执行的操作有限，编程复杂度较高。

                适合场景：对实时性要求高的场景，如实时数据采集。

        5.异步I/O：程序发起I/O操作后，立即返回，内核负责完成I/O操作。当操作完成后，内核通过回调函数或信号通知程序。

                优点：完全非阻塞，程序可以执行其他任务，效率最高。

                缺点：编程复杂度最高，需要操作系统支持。

                适合场景：高性能服务器。

        前四种都属于同步I/O。即内核向应用程序通知的是就绪事件，比如只通知有客户端连接，要求用户代码自行执行I/O操作，异步I/O是指内核向应用程序通知的是完成事件，比如读取客户端的数据后才通知应用程序，由内核完成I/O操作。

（3）事件处理模式

        1.Reactor模式

        Reactor模式是基于同步I/O的事件处理模式。它通过一个事件循环监听多个事件源（如文件描述符），当事件发生时，将事件分发给对应的处理程序。

        工作流程：1.向Reactor注册事件源和对应的事件处理器。2.Reactor调用事件多路分发器监听事件。3.当事件发生时，Readtor将事件分发给对应的事件处理器。4.事件处理器处理事件。

        优点：适合高并发场景，资源利用率高。

        缺点：事件处理逻辑与I/O操作耦合，可能影响性能。

        2.Proactor模式

        Proactor模式是基于异步I/O的事件处理模式。它将I/O操作交给操作系统完成，当操作完成后，通过回调函数通知应用程序。

        工作流程：1.应用程序向Procator注册事件源和对应的完成时间处理器。2.Proactor发起异步I/O操作。3.当异步操作完成时，操作系统通知Proactor。4.Proactor调用对应的完成事件处理器处理结果。

        优点：完全非阻塞，性能极高。适合处理大量I/O密集型任务。

        缺点：编程复杂度高，需要操作系统支持异步I/O。

（4）并发编程模式

        并发编程方法的实现有多进程和多线程两种。但这里涉及的并发模式指I/O处理单元与逻辑单元的协同完成任务的方法。

        半同步/半异步模式是一种结合了同步和异步优点的并发编程模式，常用于高性能服务器设计中。它通过将任务分为同步和异步两部分，既保证了响应速度，又简化了编程复杂度。

        其核心思想是将系统分为两层：

        1.异步层：负责处理I/O事件，使用非阻塞I/O和事件驱动机制。

        2.同步层：负责处理业务逻辑，使用多线程或多进程。

        优点：异步层高效处理I/O事件，保证响应速度。同步层简化业务逻辑开发，避免回调地狱。

        缺点：需要额外的队列或消息传递机制，可能引入延迟。异步层和同步层的划分需要合理设计。

• 同步指的是程序完全按照代码序列的顺序执行

• 异步指的是程序的执行需要由系统事件驱动

（5）半同步/半反应堆

        半同步/半反应堆并发模式是半同步/半异步的变体，将半异步具体化为某种事件处理模式。

其工作流程为：

• 主线程充当异步线程，负责监听所有socket上的事件

• 若有新请求到来，主线程接收之以得到新的连接socket，然后往epoll内核事件表中注册该socket上的读写事件

• 如果连接socket上有读写事件发生，主线程从socket上接收数据，并将数据封装成请求对象插入到请求队列中

• 所有工作线程睡眠在请求队列上，当有任务到来时，通过竞争（如互斥锁）获得任务的接管权

（6）线程池

       可以参考这篇文章——  C++之线程池（Thread Pool）-CSDN博客

（7）静态成员变量与静态成员函数

        参考这篇文章——C++关键字之static-CSDN博客

（8）pthread_create与this指针陷阱

        函数原型

#include <pthread.h>
2int pthread_create (pthread_t *thread_tid,                 //返回新生成的线程的id
3                    const pthread_attr_t *attr,         //指向线程属性的指针,通常设置为NULL
4                    void * (*start_routine) (void *),   //处理线程函数的地址
5                    void *arg);                         //start_routine()中的参数

        函数原型中的第三个参数，为函数指针，指向处理线程函数的地址。该函数，要求为静态函数。如果处理线程函数为类成员函数时，需要将其设置为静态成员函数。

        若线程函数为类成员函数，则this指针会作为默认的参数被传进函数中，从而和线程函数参数(void*)不能匹配，不能通过编译。静态成员函数就没有这个问题，里面没有this指针。

2.线程池分析

        线程池的设计模式为半同步/半反应堆，其中反应堆具体为Procator事件处理模式。

        具体的，主线程为异步线程，负责监听文件描述符，接收socket新连接，若当前监听的socket发生了读写事件，然后将任务插入到请求队列。工作线程从请求队列中取出任务，完成读写数据的处理。

（1）线程池类定义

1template<typename T>2class threadpool{3    public:4        //thread_number是线程池中线程的数量5        //max_requests是请求队列中最多允许的、等待处理的请求的数量6        //connPool是数据库连接池指针7        threadpool(connection_pool *connPool, int thread_number = 8, int max_request = 10000);8        ~threadpool();9
10        //像请求队列中插入任务请求
11        bool append(T* request);
12
13    private:
14        //工作线程运行的函数
15        //它不断从工作队列中取出任务并执行之
16        static void *worker(void *arg);
17
18        void run();
19
20    private:
21        //线程池中的线程数
22        int m_thread_number;
23
24        //请求队列中允许的最大请求数
25        int m_max_requests;
26
27        //描述线程池的数组，其大小为m_thread_number
28        pthread_t *m_threads;
29
30        //请求队列
31        std::list<T *>m_workqueue;    
32
33        //保护请求队列的互斥锁    
34        locker m_queuelocker;
35
36        //是否有任务需要处理
37        sem m_queuestat;
38
39        //是否结束线程
40        bool m_stop;
41
42        //数据库连接池
43        connection_pool *m_connPool;  
44};

（2）线程池创建与回收

        构造函数中创建线程池,pthread_create函数中将类的对象作为参数传递给静态函数(worker),在静态函数中引用这个对象,并调用其动态方法(run)。

        具体的，类对象传递时用this指针，传递给静态函数后，将其转换为线程池类，并调用私有成员函数run。

 1   template<typename T>2   threadpool<T>::threadpool( connection_pool *connPool, int thread_number, int max_requests) : m_thread_number(thread_number), m_max_requests(max_requests), m_stop(false), m_threads(NULL),m_connPool(connPool){34    if(thread_number<=0||max_requests<=0)5        throw std::exception();67    //线程id初始化8    m_threads=new pthread_t[m_thread_number];9    if(!m_threads)
10        throw std::exception();
11    for(int i=0;i<thread_number;++i)
12    {
13        //循环创建线程，并将工作线程按要求进行运行
14        if(pthread_create(m_threads+i,NULL,worker,this)!=0){
15            delete [] m_threads;
16            throw std::exception();
17        }
18
19        //将线程进行分离后，不用单独对工作线程进行回收
20        if(pthread_detach(m_threads[i])){
21            delete[] m_threads;
22            throw std::exception();
23        }
24    }
25}

（3）向请求队列中添加任务

        通过list容器创建请求队列，向队列中添加时，通过互斥锁保证线程安全，添加完成后通过信号量提醒有任务要处理，最后注意线程同步。

 1template<typename T>2bool threadpool<T>::append(T* request)3{4    m_queuelocker.lock();56    //根据硬件，预先设置请求队列的最大值7    if(m_workqueue.size()>m_max_requests)8    {9        m_queuelocker.unlock();
10        return false;
11    }
12
13    //添加任务
14    m_workqueue.push_back(request);
15    m_queuelocker.unlock();
16
17    //信号量提醒有任务要处理
18    m_queuestat.post();
19    return true;
20}

（4）线程处理函数

        内部访问私有成员函数run，完成线程处理要求。

1template<typename T>
2void* threadpool<T>::worker(void* arg){
3
4    //将参数强转为线程池类，调用成员方法
5    threadpool* pool=(threadpool*)arg;
6    pool->run();
7    return pool;
8}

（5）run执行任务

        主要实现，工作线程从请求队列中取出某个任务进行处理，注意线程同步。

 1template<typename T>2void threadpool<T>::run()3{4    while(!m_stop)5    {    6        //信号量等待7        m_queuestat.wait();89        //被唤醒后先加互斥锁
10        m_queuelocker.lock();
11        if(m_workqueue.empty())
12        {
13            m_queuelocker.unlock();
14            continue;
15        }
16
17        //从请求队列中取出第一个任务
18        //将任务从请求队列删除
19        T* request=m_workqueue.front();
20        m_workqueue.pop_front();
21        m_queuelocker.unlock();
22        if(!request)
23            continue;
24
25        //从连接池中取出一个数据库连接
26        request->mysql = m_connPool->GetConnection();
27
28        //process(模板类中的方法,这里是http类)进行处理
29        request->process();
30
31        //将数据库连接放回连接池
32        m_connPool->ReleaseConnection(request->mysql);
33    }
34}