[计网底层小探索]:实现并部署多线程并发Tcp服务器框架(基于生产者消费者模型的线程池结构)

文章目录

• 一.网络层与传输层协议
• • sockaddr结构体继承体系(Linux体系)
  • 贯穿计算机系统的网络通信架构图示:
• 二.实现并部署多线程并发Tcp服务器框架
• • 线程池模块
  • 序列化反序列化工具模块
  • 通信信道建立模块
  • 服务器主体模块
  • 任务回调模块(根据具体应用场景可重构)
  • Tips:DebugC++代码过程中遇到的问题记录

一.网络层与传输层协议

• 网络层与传输层内置于操作系统的内核中,网络层一般使用ip协议,传输层常用协议为Tcp协议和Udp协议,Tcp协议和Udp协议拥有各自的特点和应用场景:

sockaddr结构体继承体系(Linux体系)

• sockaddr_in结构体用于存储网络通信主机进程的ip和端口号等信息

贯穿计算机系统的网络通信架构图示:

二.实现并部署多线程并发Tcp服务器框架

小项目的完整文件的gittee链接

• Tcp服务器架构:

线程池模块

#pragma once
#include <iostream>
#include <pthread.h>
#include \”log.hpp\”
#include <semaphore.h>
#include <vector>
#include <cstdio>

template<class T>
class RingQueue{

private:
pthread_mutex_t Clock_;
pthread_mutex_t Plock_;
sem_t Psem_;
sem_t Csem_;
std::vector<T> Queue_;
int Pptr_;
int Cptr_;
int capacity_;
public:
RingQueue(int capacity = 10) : Queue_(capacity),Pptr_(0),Cptr_(0),capacity_(capacity){

sem_init(&Psem_,0,capacity);
sem_init(&Csem_,0,0);
pthread_mutex_init(&Clock_,nullptr);
pthread_mutex_init(&Plock_,nullptr);
}
~RingQueue(){

sem_destroy(&Psem_);
sem_destroy(&Csem_);
pthread_mutex_destroy(&Clock_);
pthread_mutex_destroy(&Plock_);
}
T Pop(){

sem_wait(&Csem_);
pthread_mutex_lock(&Clock_);
T tem = Queue_[Cptr_];
Cptr_++;
Cptr_ %= capacity_;
pthread_mutex_unlock(&Clock_);
sem_post(&Psem_);
return tem;
}
void Push(T t){

sem_wait(&Psem_);
pthread_mutex_lock(&Plock_);
Queue_[Pptr_] = t;
Pptr_++;
Pptr_%= capacity_;
pthread_mutex_unlock(&Plock_);
sem_post(&Csem_);
}
};

#pragma once
#include \”sem_cp.cpp\”
#include <pthread.h>
#include <iostream>
#include <string>
#include <mutex>
#include \”CalTask.cpp\”

template<class Task>
class Thread_Pool{

struct Thread_Data{

int Thread_num;
pthread_t tid;
};
private:
RingQueue<Task> Queue_; //线程安全的环形队列
std::vector<Thread_Data> thread_arr; //管理线程的容器
static std::mutex lock_; //单例锁
static Thread_Pool<Task> * ptr_; //单例指针
private:
Thread_Pool(int capacity_Of_queue = 20) : Queue_(capacity_Of_queue){
}
Thread_Pool(const Thread_Pool<Task>& Tp) = delete;
Thread_Pool<Task>& operator=(const Thread_Pool<Task> & Tp) = delete;
public:
~Thread_Pool(){
}
//获取线程池单例–>注意C++的类模板静态成员函数需要在类体外进行定义
static Thread_Pool<Task> * Getinstance();
//创建多线程
void Create_thread(int thread_num = 10){

Thread_Data T_data;
for(int i = 0 ; i < thread_num ; ++i){

//注意线程池对象的this指针传递给线程
pthread_create(&T_data.tid,nullptr,Routine,this);
T_data.Thread_num = i + 1;
thread_arr.push_back(T_data);
}
}
//线程等待
void Thread_join(){

for(int i = 0 ;i < thread_arr.size() ; ++i){

pthread_join(thread_arr[i].tid,nullptr);
}
}