@bit::Shadow
✧(≖ ◡ ≖✿
目录
[基于服务端初始化( accept() )后Run()](#基于服务端初始化( accept() )后Run())
②使用if(fork()>0)实现孙子进程执行任务，父进程回收但几乎不阻塞
TcpServer类的内部类ThreadData用于存储对象
gitee三版本（必看）
单进程、单线程
实际生产中不会使用。
多进程版本
无论是多进程还是多线程都是服务于小型服务。
长服务：多进程、多线程合适。（xshell）
短服务：线程池合适。（用一次即结束）
多进程的设计理念：父进程不断accept接受子进程，子进程完成任务。
基于服务端初始化( accept() )后Run()
以下均测试通过
父子进程处理原则的模板（目前未处理）
cpp
void Run()
{
//指在服务端监听后的其二处理模块
assert (!_running);//强限定
_running = true;
while(_running)
{
//accept接受服务端的监听listensockfd
struct sockaddr_in client;
socklen_t len = sizeof (len);
//阻塞等待
int sockfd = accept (_listenSockfd, (struct sockaddr *)&client, &len);
if(sockfd < 0)//-1or返回新的文件描述符
{
//此处很复杂，由于当前处于初级学习阶段仅做如此处理
LOG (LogLevel::FATAL) << "accept faliure";
exit (ACCEPT_ERROR);
}
//vsersion 1 多进程(常用来处理小型任务)
// 父进程不断accept接受子进程，子进程完成任务。
pid_t pid = fork ();
if(pid < 0)
{
LOG (LogLevel::ERROR) << "多进程创建错误";
exit (FORK_ERROR);
}
else if(pid == 0)
{
// 子进程
//1. 一文件描述符若不再有进程维护，会怎么样？
// 答：默认被系统自动回收♻️
//2. fork的本质是"进程地址表"的拷贝
// (必做)关闭不必要的文件描述符(健壮性)
int ret = close (_listenSockfd);
if(ret < 0)
{
LOG (LogLevel::ERROR) << "子进程close failure";
exit (CLOSE_ERROR);
}
Handle (sockfd);
exit (EXIT_SUCCESS);
}
else // pid > 0 pid是子进程的pid
{
//父进程
//关闭不必要的文件描述符+子进程处理
int ret = close (sockfd);
if(ret < 0)
{
LOG (LogLevel::ERROR) << "父进程进程close failure" << "其子进程为:" << pid;
exit (CLOSE_ERROR);
}
//子进程待处理
}/*pid*/
}/*while*/
}/*Run*/①父进程信号忽略
父进程提前处理signal(SIGCHLD, SIG_IGN); 父进程再无需等待子进程
cpp
void Run()
{
//指在服务端监听后的其二处理模块
assert (!_running);//强限定
_running = true;
////////////////////////////////////////
//多进程处理法则
signal (SIGCHLD, SIG_IGN);//父进程忽略子进程退出信号由系统代理
////////////////////////////////////////
while(_running)
{
//accept接受服务端的监听listensockfd
struct sockaddr_in client;
socklen_t len = sizeof (len);
//阻塞等待
int sockfd = accept (_listenSockfd, (struct sockaddr *)&client, &len);
if(sockfd < 0)//-1or返回新的文件描述符
{
//此处很复杂，由于当前处于初级学习阶段仅做如此处理
LOG (LogLevel::FATAL) << "accept faliure";
exit (ACCEPT_ERROR);
}
printf ("服务端aceept成功\n");
// sockfd client len
//vsersion 1 多进程(常用来处理小型任务)
// 父进程不断accept接受子进程，子进程完成任务。
pid_t pid = fork ();
if(pid < 0)
{
LOG (LogLevel::ERROR) << "多进程创建错误";
exit (FORK_ERROR);
}
else if(pid == 0)
{
// (必做)关闭不必要的文件描述符(健壮性)
int ret = close (_listenSockfd);
if(ret < 0)
{
LOG (LogLevel::ERROR) << "子进程close failure";
exit (CLOSE_ERROR);
}
Handle (sockfd);
exit (EXIT_SUCCESS);//由于signal (SIGCHLD, SIG_IGN)系统自动回收
}
else // pid > 0 pid是子进程的pid
{
//父进程
//关闭不必要的文件描述符+子进程处理
int ret = close (sockfd);
if(ret < 0)
{
LOG (LogLevel::ERROR) << "父进程进程close failure" << "其子进程为:" << pid;
exit (CLOSE_ERROR);
}
//子进程处理
// signal(SIGCHLD, _SIG_IGN) 父进程无需等待
}/*pid*/
}/*while*/
_running = false;
}/*Run*/②使用if(fork()>0)实现孙子进程执行任务，父进程回收但几乎不阻塞
cpp
void Run()
{
//指在服务端监听后的其二处理模块
assert (!_running);//强限定
_running = true;
while(_running)
{
//accept接受服务端的监听listensockfd
struct sockaddr_in client;
socklen_t len = sizeof (len);
//阻塞等待
int sockfd = accept (_listenSockfd, (struct sockaddr *)&client, &len);
if(sockfd < 0)//-1or返回新的文件描述符
{
//此处很复杂，由于当前处于初级学习阶段仅做如此处理
LOG (LogLevel::FATAL) << "accept faliure";
exit (ACCEPT_ERROR);
}
printf ("服务端aceept成功\n");
//vsersion 1 多进程(常用来处理小型任务)
// 父进程不断accept接受子进程，子进程完成任务。
pid_t pid = fork ();
if(pid < 0)
{
LOG (LogLevel::ERROR) << "多进程创建错误";
exit (FORK_ERROR);
}
else if(pid == 0)
{
// (必做)关闭不必要的文件描述符(健壮性)
int ret = close (_listenSockfd);
if(ret < 0)
{
LOG (LogLevel::ERROR) << "子进程close failure";
exit (CLOSE_ERROR);
}
//version 2
if(fork()>0)//子进程创建孙子进程
{
LOG (LogLevel::INFO)
<< "子进程退出孙子进程执行任务pid:" << pid;
exit (EXIT_SUCCESS);
}
//子进程已退出，孙子进程执行任务。导致父进程不再阻塞(成功执行回收逻辑)
Handle (sockfd);
exit (EXIT_SUCCESS);
}
else // pid > 0 pid是子进程的pid
{
//父进程
//关闭不必要的文件描述符+子进程处理
int ret = close (sockfd);
if(ret < 0)
{
LOG (LogLevel::ERROR) << "父进程进程close failure" << "其子进程为:" << pid;
exit (CLOSE_ERROR);
}
//子进程处理
// signal(SIGCHLD, _SIG_IGN) 父进程无需等待
int ret2 = wait (&pid);
if(ret2 < 0)
{
LOG (LogLevel::ERROR)
<< "父进程等待错误，子进程pid:" << pid;
exit (WAIT_ERROR);
}
} /*pid*/
}/*while*/
_running = false;
} /*Run*/多线程版本
测试通过
在搭建时你发现如果不采用内部类（ThreadData），传参问题无法解决（这是受新线程直接调用Handle的原因）多个参数tid sockfd及Handle 因此我们引入ThreadData类对象存储此多个元素实现调用。
较于多进程新线程要接入到Handle必须传递两个参数：1.sokcfd 2.tid 为了实现pthread_detatch与Hanlde传参的要求。
TcpServer::Run()
cpp
void Run()
{
//指在服务端监听后的其二处理模块
assert (!_running);//强限定
_running = true;
while(_running)
{
//accept接受服务端的监听listensockfd
struct sockaddr_in client;
socklen_t len = sizeof (len);
// printf ("111\n");
//阻塞等待
int sockfd = accept (_listenSockfd, (struct sockaddr *)&client, &len);
if(sockfd < 0)//-1or返回新的文件描述符
{
//此处很复杂，由于当前处于初级学习阶段仅做如此处理
LOG (LogLevel::FATAL) << "accept faliure";
exit (ACCEPT_ERROR);
}
printf ("服务端aceept成功\n");
// version 3多线程
// 使得新线程调用Handle,主线程依旧循环接收服务端链接信号
pthread_t td;
// 应该怎样记录td?
ThreadData ThDa(sockfd, td, Handle); //类内类对象存储成员实现单变量传递
// int ret3 = pthread_create (&td, nullptr, Handle, &sockfd);重载的话代码复用大忌
//新引入一中间介质成功转换
int ret3 = pthread_create (&ThDa._td, nullptr, Routine2, &ThDa);
//line 149 blog总结
} /*while*/
_running = false;
} /*Run*/TcpServer类的内部类ThreadData用于存储对象
注意函数包装器的使用
cpp
struct ThreadData
{
ThreadData(int sockfd, pthread_t td, void(*funt)(int))
:_sockfd(sockfd), _td(td), _func(funt)
{}
int _sockfd;
pthread_t _td;
std::function<void (int)> _func;
};TcpServer::Routine2()路由
通过类内类对象实现函数调用
cpp
static void* Routine2(void* arg)
{
ThreadData *threadData = static_cast<ThreadData *> (arg);
//detatch分离!!!
pthread_detach (threadData->_td);
threadData->_func (threadData->_sockfd);
}不得已只得将Handle变为静态属性。
线程池
核心
cpp
// Run()
ThreadPool<std::function<void ()>>::GetInstance () \
->Enqueue ([this, sockfd] () { this->Handle (sockfd); });感谢支持，长期连载
欢迎关注
