目录
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){
3
4 if(thread_number<=0||max_requests<=0)
5 throw std::exception();
6
7 //线程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();
5
6 //根据硬件，预先设置请求队列的最大值
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();
8
9 //被唤醒后先加互斥锁
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}
![蓝桥杯[每日两题] 真题：好数 神奇闹钟 (java版)](https://i-blog.csdnimg.cn/direct/e0a16c29d478450ea8e768de97f6e63d.png)
