简单的TCP网络程序·多进程、多线程(后端服务器）
前文链接 -- 简单的TCP网络程序·单进程
上篇文章中，实现了TCP网络通信的的单进程版本，因为实现的是一个死循环的逻辑，是串行实运行的，显然这和实际中的TCP通信是不同的，为了解决这方面的问题，需要使用多进程、多线程的方式去解决,这里就直接写了
目录
版本二：多进程
接口1：fork
细节1：父进程直接等待吗？
解决方法1：利用孤儿进程特性
测试结果1
解决方法2：信号捕捉
细节2：父进程要关闭自己不用的文件描述符
测试结果2
多进程版本修改代码
函数1：start()
版本三：多线程
对象类型：pthread_t -- 需填写
接口3：pthread_detach()
接口4：pthread_self()
版本三：多线程版的修改区域
函数2：threadRoutine()
多线程传参对象：ThreadData
细节3：编译的时候记得带上 lpthread
测试3：多线程的测试
细节4：使用本地回环的时候操作符会多用一个
测试4：多线程的测试 -- 在监控脚本下观看链接状态
监控脚本：
全部代码
tcpClient.cc
tcpClient.hpp
tcpServer.cc
tcpServer.hpp
log.hpp
makefile
版本二：多进程
接口1：fork
注意子进程会继承父进程的一些东西,父进程的文件操作符就会被子进程继承，即父进程的文件操作符那个数字会被继承下来，指向同一个文件，但是文件本身不会被拷贝一份，也就是说子进程可以看到父进程创建的文件描述符sock和打开的listensock
细节1：父进程直接等待吗？
显然这里不能单纯的等待，这样又会回归串行运行了，因为等待的时候会阻塞式等待，且这里并不适用非阻塞式等待，因为当有一百个链接来了，就有一百个进程运行，因为非阻塞，就会回到开始，一但后面没有链接到来的话，那么accept这里就等不到了，再也不会返回，这些进程就不会再也不会被回收了
解决方法1：利用孤儿进程特性
我们可以直接让操作系统领养这里的子进程，直接退出，让孙子进程来做服务
测试结果1
解决方法2：信号捕捉
上面的一种用法是一种巧妙的用法，不过我们这里正常来说使用信号捕捉就行了，这样可以避免一直反复在创建子进程
为SIGCHLD建立信号处理程序
即无论一个子进程于何时终止，系统都会向其父进程发送 SIGCHLD 信号**。对该信号的默认处理是将其忽略，不过也可以按照信号处理程序来捕获它
细节2：父进程要关闭自己不用的文件描述符
文件描述符会越来越大，因为老的文件描述符一直正在被使用，如图所示，文件描述符会一直增大，即使链接已经断开了
一定要关掉，否则就会造成文件描述符泄漏，但是这里的关掉要注意了，这里只是把文件描述符的计数-1，这个文件描述符子进程已经继承过去了，所以这里也可以看做，父进程立马把文件描述符计数-1，只有当子进程关闭的时候，这个文件描述符真正的被关闭了，所以后面申请的链接使用的还是这个4号文件描述符，因为计算机太快了
测试结果2
至此多进程版本完成
多进程版本修改代码
函数1：start()
注意头文件的引入
void start()
{
//解决方法2：信号捕捉
signal(SIGCHLD, SIG_IGN); // SIG_IGN：忽略
for (;;) // 一个死循环
{
// 4. server 获取新链接
// sock 和client 进行通信的fd
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
if (sock < 0)
{
logMessage(ERROR, "accept error, next"); // 这个不影响服务器的运行，用ERROR，就像张三不会因为没有把人招呼进来就不干了
continue;
}
logMessage(NORMAL, "accept a new link success");
std::cout << "sock: " << sock << std::endl;
// 5. 这里就是一个sock， 未来通信我们就用这个sock， 面向字节流的，后续全部都是文件操作！
// 我们就可以直接使用read之类的面向字节流的操作都行
/*
// version 1 -- 单进程
serviceIO(sock);
close(sock); // 走到这里就说明客户端已经关闭
// 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符会越来越少，因为文件描述符本质就是一个数组下标
// 只要是数组下标就会有尽头，提供服务的上限 就等于文件描述符的上限
// 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符泄漏
*/
// version 2 多进程版(2) -- 注意子进程会继承父进程的一些东西,父进程的文件操作符就会被子进程继承，
// 即父进程的文件操作符那个数字会被继承下来，指向同一个文件，但是文件本身不会被拷贝一份
// 也就是说子进程可以看到父进程创建的文件描述符sock和打开的listensock
pid_t id = fork();
if (id == 0) // 当id为 0 的时候就代表这里是子进程
{
// 关闭不需要的文件描述符 listensock -- 子进程不需要监听，所以我们要关闭这个不需要的文件描述符
// 即使这里不关，有没有很大的关系，但是为了防止误操作我们还是关掉为好
close(_listensock);
//if(fork()>0) exit(0); 解决方法1：利用孤儿进程特性
serviceIO(sock);
close(sock);
exit(0);
}
// 一定要关掉，否则就会造成文件描述符泄漏，但是这里的关掉要注意了，这里只是把文件描述符的计数-1
// 子进程已经继承过去了，所以这里也可以看做，父进程立马把文件描述符计数-1，只有当子进程关闭的时候，这个文件描述符真正的被关闭了
// 所以后面申请的链接使用的还是这个4号文件描述符，因为计算机太快了
close(sock);
//father
// 那么父进程干嘛呢？ 直接等待吗？ -- 显然不能，这样又会回归串行运行了，因为等待的时候会阻塞式等待
// 且这里并不能用非阻塞式等待，因为万一有一百个链接来了，就有一百个进程运行，如果这里非阻塞式等待
// 一但后面没有链接到来的话.那么accept这里就等不到了，这些进程就不会回收了
//不需要等待了
/*pid_t ret = waitpid(id, nullptr, 0);
if(ret > 0)
{
std::cout<< "wait success: " << ret << std::endl;
}
*/
}
}版本三：多线程
由于创建进程的消耗比较大，所以这里再提供一个多线程版本的
对象类型：pthread_t -- 需填写
参考文献 -- pthread_create()函数：创建线程
接口3：pthread_detach()
int pthread_detach(pthread_t thread); 成功：0；失败：错误号
作用：从状态上实现线程分离，注意不是指该线程独自占用地址空间。
线程分离状态：指定该状态，线程主动与主控线程断开关系。线程结束后（不会产生僵尸线程），其退出状态不由其他线程获取，而直接自己自动释放（自己清理掉PCB的残留资源）。网络、多线程服务器常用。
接口4：pthread_self()
作用：获取自身id
版本三：多线程版的修改区域
下图有个小错误，应该先close(), 再delete
函数2：threadRoutine()
// 注意因为是静态的所以，不能访问类内成员，所以我们把this指针当成参数传进来
static void *threadRoutine(void *args)
{
pthread_detach(pthread_self()); // 线程分离，这样就不需要等待了，自己结束后自己会释放
ThreadData *td = static_cast(args);
td->_self->serviceIO(td->_sock);
delete td;
close(td->_sock);
return nullptr;
} 多线程传参对象：ThreadData
在TcpServer类内，所以类内类
// 用以线程传参
class ThreadData
{
public:
ThreadData(TcpServer *self, int sock) : _self(self), _sock(sock)
{}
public:
TcpServer *_self;
int _sock;
};细节3：编译的时候记得带上 lpthread
测试3：多线程的测试
我们会发现这里的文件操作符会增加，因为随着用户的链接，这里的操作符会被使用，只有当用户断开链接的时候才会被释放
细节4：使用本地回环的时候操作符会多用一个
测试4：多线程的测试 -- 在监控脚本下观看链接状态
监控脚本：
while :; do ps -aL | head -1 && ps -aL | grep tcpserver; sleep 1; echo "#######################"; done
全部代码
tcpClient.cc
#include "tcpClient.hpp"
#include
using namespace std;
static void Usage(string proc)
{
cout << "Usage:\n\t" << proc << " serverip serverport\n\n"; // 命令提示符
}
// ./tcpclient serverip serverport 调用逻辑
int main(int argc, char *argv[])
{
if(argc != 3)
{
Usage(argv[0]);
exit(1);
}
string serverip = argv[1];
uint16_t serverport = atoi(argv[2]);
unique_ptr tcli(new TcpClient(serverip, serverport));
tcli->initClient();
tcli->start();
return 0;
} tcpClient.hpp
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define NUM 1024
class TcpClient
{
public:
TcpClient(const std::string &serverip, const uint16_t &port)
: _sock(1), _serverip(serverip), _serverport(port)
{
}
void initClient()
{
// 1. 创建socket
_sock = socket(AF_INET, SOCK_STREAM, 0);
if (_sock < 0)
{
// 客户端也可以有日志，不过这里就不再实现了，直接打印错误
std::cout << "socket create error" << std::endl;
exit(2);
}
// 2. tcp的客户端要不要bind？ 要的！ 但是不需要显示bind，这里的client port要让OS自定！
// 3. 要不要listen？ -- 不需要！客户端不需要建立链接
// 4. 要不要accept？ -- 不要！
// 5. 要什么？ 要发起链接！
}
void start()
{
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(_serverport);
server.sin_addr.s_addr = inet_addr(_serverip.c_str());
if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
{
std::cerr << "socket connect error" << std::endl;
}
else
{
std::string msg;
while (true)
{
std::cout << "Enter# ";
std::getline(std::cin, msg);
write(_sock, msg.c_str(), msg.size());
char buffer[NUM];
int n = read(_sock, buffer, sizeof(buffer) - 1);
if (n > 0)
{
// 目前我们把读到的数据当成字符串， 截至目前
buffer[n] = 0;
std::cout << "Server回显# " << buffer << std::endl;
}
else
{
break;
}
}
}
}
~TcpClient()
{
if(_sock >= 0) close(_sock); //不写也行，因为文件描述符的生命周期随进程，所以进程退了，自然也就会自动回收了
}
private:
int _sock;
std::string _serverip;
uint16_t _serverport;
}; tcpServer.cc
#include "tcpServer.hpp"
#include
using namespace server;
using namespace std;
static void Usage(string proc)
{
cout << "Usage:\n\t" << proc << " local_port\n\n"; // 命令提示符
}
// tcp服务器，启动上和udp server一模一样
// ./tcpserver local_port
int main(int argc, char *argv[])
{
if (argc != 2)
{
Usage(argv[0]);
exit(USAGE_ERR);
}
uint16_t port = atoi(argv[1]);
unique_ptr tsvr(new TcpServer(port));
tsvr->initServer();
tsvr->start();
return 0;
} tcpServer.hpp
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "log.hpp"
namespace server
{
enum
{
USAGE_ERR = 1,
SOCKET_ERR,
BIND_ERR,
LISTEN_ERR
};
static const uint16_t gport = 8080;
static const int gbacklog = 5; // 10、20、50都可以，但是不要太大比如5千，5万
class TcpServer; // 声明
// 用以线程传参
class ThreadData
{
public:
ThreadData(TcpServer *self, int sock) : _self(self), _sock(sock)
{}
public:
TcpServer *_self;
int _sock;
};
class TcpServer
{
public:
TcpServer(const uint16_t &port = gport) : _listensock(-1), _port(port)
{
}
void initServer()
{
// 1. 创建socket文件套接字对象 -- 流式套接字
_listensock = socket(AF_INET, SOCK_STREAM, 0); // 第三个参数默认 0
if (_listensock < 0)
{
logMessage(FATAL, "create socket error");
exit(SOCKET_ERR);
}
logMessage(NORMAL, "create socket success");
// 2.bind绑定自己的网路信息 -- 注意包含头文件
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(_port); // 这里有个细节，我们会发现当我们接受数据的时候是不需要主机转网路序列的，因为关于IO类的接口，内部都帮我们实现了这一功能，这里不帮我们做是因为我们传入的是一个结构体，系统做不到
local.sin_addr.s_addr = INADDR_ANY; // 接受任意ip地址
if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
{
logMessage(FATAL, "bind socket error");
exit(BIND_ERR);
}
logMessage(NORMAL, "bind socket success");
// 3. 设置socket 为监听状态 -- TCP与UDP不同，它先要建立链接之后，TCP是面向链接的，后面还会有“握手”过程
if (listen(_listensock, gbacklog) < 0) // 第二个参数backlog后面再填这个坑
{
logMessage(FATAL, "listen socket error");
exit(LISTEN_ERR);
}
logMessage(NORMAL, "listen socket success");
}
void start()
{
// 解决方法2：信号捕捉 版本二
// signal(SIGCHLD, SIG_IGN); // SIG_IGN：忽略
for (;;) // 一个死循环
{
// 4. server 获取新链接
// sock 和client 进行通信的fd
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
if (sock < 0)
{
logMessage(ERROR, "accept error, next"); // 这个不影响服务器的运行，用ERROR，就像张三不会因为没有把人招呼进来就不干了
continue;
}
logMessage(NORMAL, "accept a new link success");
std::cout << "sock: " << sock << std::endl;
// 5. 这里就是一个sock， 未来通信我们就用这个sock， 面向字节流的，后续全部都是文件操作！
// 我们就可以直接使用read之类的面向字节流的操作都行
/*
// version 1 -- 单进程
serviceIO(sock);
close(sock); // 走到这里就说明客户端已经关闭
// 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符会越来越少，因为文件描述符本质就是一个数组下标
// 只要是数组下标就会有尽头，提供服务的上限 就等于文件描述符的上限
// 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符泄漏
*/
// version 2 多进程版(2) -- 注意子进程会继承父进程的一些东西,父进程的文件操作符就会被子进程继承，
// 即父进程的文件操作符那个数字会被继承下来，指向同一个文件，但是文件本身不会被拷贝一份
// 也就是说子进程可以看到父进程创建的文件描述符sock和打开的listensock
/*pid_t id = fork();
if (id == 0) // 当id为 0 的时候就代表这里是子进程
{
// 关闭不需要的文件描述符 listensock -- 子进程不需要监听，所以我们要关闭这个不需要的文件描述符
// 即使这里不关，有没有很大的关系，但是为了防止误操作我们还是关掉为好
close(_listensock);
//if(fork()>0) exit(0); 解决方法1：利用孤儿进程特性
serviceIO(sock);
close(sock);
exit(0);
} */
// 一定要关掉，否则就会造成文件描述符泄漏，但是这里的关掉要注意了，这里只是把文件描述符的计数-1
// 子进程已经继承过去了，所以这里也可以看做，父进程立马把文件描述符计数-1，只有当子进程关闭的时候，这个文件描述符真正的被关闭了
// 所以后面申请的链接使用的还是这个4号文件描述符，因为计算机太快了
// close(sock);
// father
// 那么父进程干嘛呢？ 直接等待吗？ -- 显然不能，这样又会回归串行运行了，因为等待的时候会阻塞式等待
// 且这里并不能用非阻塞式等待，因为万一有一百个链接来了，就有一百个进程运行，如果这里非阻塞式等待
// 一但后面没有链接到来的话.那么accept这里就等不到了，这些进程就不会回收了
// 不需要等待了 version 2
/*pid_t ret = waitpid(id, nullptr, 0);
if(ret > 0)
{
std::cout<< "wait success: " << ret << std::endl;
}
*/
// version 3 多线程
// 线程不需要关闭文件操作符，且看的到进程的共享资源
pthread_t tid;
ThreadData *td = new ThreadData(this, sock);
pthread_create(&tid, nullptr, threadRoutine, td); // 把this传过去
// pthread_join(tid, nullptr); 不能阻塞式等待 -- 这样又会会到之前的串行运行了
// 所以我们直接线程分离， 这样就不需要等待了
}
}
// 注意因为是静态的所以，不能访问类内成员，所以我们把this指针当成参数传进来
static void *threadRoutine(void *args)
{
pthread_detach(pthread_self()); // 线程分离，这样就不需要等待了，自己结束后自己会释放
ThreadData *td = static_cast(args);
td->_self->serviceIO(td->_sock);
close(td->_sock);
delete td;
return nullptr;
}
void serviceIO(int sock)
{
// 先用最简单的，读取再写回去
char buffer[1024];
while (true)
{
ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
if (n > 0)
{
// 截至目前，我们把读到的数据当作字符串
buffer[n] = 0;
std::cout << "recv message: " << buffer << std::endl;
std::string outbuffer = buffer;
outbuffer += "server[echo]";
write(sock, outbuffer.c_str(), outbuffer.size()); // 在多路转接的时候再详谈write的返回值
}
else if (n == 0)
{
// 代表client退出 -- 把它想象成一个建立好的管道，客户端不写了，并且把它的文件描述符关了，读端就会像管道一样读到 0 TCP同理
logMessage(NORMAL, "client quit, me too!");
break;
}
}
}
~TcpServer() {}
private:
int _listensock; // 修改二：改为listensock 不是用来进行数据通信的，它是用来监听链接到来，获取新链接的！
uint16_t _port;
};
} // namespace server log.hpp
#pragma once
#include
#include
// 定义五种不同的信息
#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3 //一种不影响服务器的错误
#define FATAL 4 //致命错误
void logMessage(int level, const std::string message)
{
// 格式如下
// [日志等级] [时间戳/时间] [pid] [message]
// [FATAL0] [2023-06-11 16:46:07] [123] [创建套接字失败]
// 暂定
std::cout << message << std::endl;
} makefile
cc=g++
.PHONY:all
all:tcpserver tcpclient
tcpclient:tcpClient.cc
$(cc) -o $@ $^ -std=c++11
tcpserver:tcpServer.cc
$(cc) -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm -f tcpserver tcpclient线程池版本转下篇 -- 简单的TCP网络程序·线程池(后端服务器)