TCP客户端服务器端通信（线程池版）

1、什么是监听套接字，和UDP相比，TCP为什么文件描述符变多了？

       在网络编程中，TCP和UDP是两种常见的传输协议，它们之间最大的不同之一在于连接的管理方式。为了更好地理解这个区别，我们可以用一个生动的比喻来说明。

        假设你在一家餐馆工作，其中张三负责把客人带到座位上，而李四和王五是服务员，他们负责为客人点菜和服务。张三的角色类似于TCP连接中的监听套接字。他的工作是确保当客户到达时，他们能够被快速、有效地分配给一个合适的服务员。

        在TCP协议中，监听套接字（就像张三）是独特的：它负责创建监听端口，通过这个端口，服务器可以接收到请求。当有新的连接请求时，该监听套接字的角色是“接客”，将请求转交给一个新的文件描述符（类似李四或王五），这个新的文件描述符负责具体的数据传输和处理。因此，虽然张三（监听套接字）数量是固定的，但却需要多个“服务员”来处理多个客户连接，即多个文件描述符。相比之下，UDP协议不需要这种复杂的连接管理机制，因为它是无连接的，不需要维护任何长时间的连接状态，因此它的文件描述符相对少。

2、如果现在还没写客户端，只写了服务器端，怎么测试当前服务器通信的时候会有别人来连我呢？工具：telnet 127.0.0.1 8888(底层默认tcp)

当你正在开发一个服务器应用程序，但还没有编写客户端时，你可能会想测试服务器的连接和通信功能。这时，我们可以使用一个简单的工具——telnet。假设你的服务器正在本地计算机上运行，并监听8888端口，你可以在命令行中输入以下命令来测试连接：

要检查当前活跃的网络连接，可以使用以下命令：

netstat -nltp 

服务器端代码写好了，直接用工具来测试。

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include "Log.hpp"
#include <string>
#include <arpa/inet.h>
#include <cstring>
#include <netinet/in.h>const int defaultfd=-1;
const std::string defaultip="0.0.0.0";
const int backlog=10;//一般不要设置的太大，后面解释
Log lg;
enum{SOCKET_ERR=2,BIND_ERR,Listen_ERR
};
class TcpServer
{
public:TcpServer(const uint16_t &port,const std::string &ip=defaultip):listensock_(defaultfd),port_(port),ip_(ip){};void InitServer(){listensock_=socket(AF_INET,SOCK_STREAM,0);if(listensock_<0){lg(Fatal,"errno:%d,errrstring:%s",errno,strerror(errno));exit(SOCKET_ERR);}lg(Info,"create socket success,listensock_:%d",listensock_);struct sockaddr_in local; //服务器信息memset(&local,0,sizeof(local));local.sin_family=AF_INET;local.sin_port=htons(port_); //用户在构建服务器时就需要告诉我inet_aton(ip_.c_str(),&(local.sin_addr));local.sin_addr.s_addr=INADDR_ANY; //或者写成0if(bind(listensock_,(const sockaddr*)&local,sizeof(local))<0){lg(Fatal,"bind error,errno:%d,errrstring:%s",errno,strerror(errno));exit(BIND_ERR);}lg(Info,"bind success");//和UDP不一样的地方，设为监听状态 Tcp是面向链接的，服务器一般是比较被动的。服务器一直处于一种，一直在等待连接到来的状态if(listen(listensock_,backlog)<0){lg(Fatal,"errno:%d,errrstring:%s",errno,strerror(errno));exit(Listen_ERR);}}void Start(){lg(Info, "tcpserver is running....");while (true){// 1.获取新连接struct sockaddr_in client;socklen_t len = sizeof(client);int sockfd = accept(listensock_, (struct sockaddr *)&client, &len);if (sockfd < 0){lg(Warning, "errno:%d,errrstring:%s", errno, strerror(errno));//获取连接失败，就直接再去获取continue;}//到底是谁连接的我uint16_t clientport=ntohs(client.sin_port); //网络转主机char clientip[32];std::string ip=inet_ntop(AF_INET,&(client.sin_addr),clientip,sizeof(clientip));//把客户端的ip存到ipstr中//2.根据新连接进行通信// lg(Info,"get a new Link...,sockfd:%d,client ip:%s,client port:%d",sockfd,clientip,clientport);//version 1Service(sockfd,ip,clientport);//拿到客户端的端口和ip}}void Service(int sockfd,const std::string &clientip,uint16_t &clientport){char buffer[4096];//测试代码：你给我发什么我就给你响应什么while(true){ssize_t n=read(sockfd,buffer,sizeof(buffer));if(n>0){buffer[n]=0;std::cout<<"client say#"<<buffer<<std::endl;std::string echo_string="tpserver echo#";echo_string+=buffer;write(sockfd,echo_string.c_str(),echo_string.size()); //再写回去}}}~TcpServer(){}; 
private:int listensock_;uint16_t port_;std::string ip_;
};

测试：ctrl+] 进入    ctrl+] quit退出

 

发现客户端发的aaaaa，服务器端收到了。

问题1：要是客户端退出，服务器会怎么办？

服务器会读到0，服务中止，服务器端也直接退出

问题2：服务器向一个不存在的fd写入

signal(SIGPIPE,SIG_IGN);//防止出现写入的时候，向一个已经关闭的文件描述符写入的时候，此时连接没有意义，这时写时，os直接SIGPIPE掉

3、代码

TcpServer.hpp#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include "Log.hpp"
#include <string>
#include <arpa/inet.h>
#include <cstring>
#include <netinet/in.h>
#include <unistd.h>
#include <signal.h>
#include<sys/wait.h>
#include<pthread.h>
#include "ThreadPool.hpp"
#include"Task.hpp"
#include<signal.h>
const int defaultfd=-1;
const std::string defaultip="0.0.0.0";
const int backlog=10;//一般不要设置的太大，后面解释
Log lg;
enum{SOCKET_ERR=2,BIND_ERR,Listen_ERR
};
class TcpServer;
class ThreadData//把TcpServer本身传进来
{
public:ThreadData(int fd,const std::string &ip,const uint16_t &port,TcpServer *t):sockfd(fd),clientip(ip),clientport(port),tsvr(t){}
public:int sockfd;std::string clientip;uint16_t clientport;TcpServer *tsvr;
};
class TcpServer
{
public:TcpServer(const uint16_t &port,const std::string &ip=defaultip):listensock_(defaultfd),port_(port),ip_(ip){};void InitServer(){listensock_=socket(AF_INET,SOCK_STREAM,0);if(listensock_<0){lg(Fatal,"errno:%d,errrstring:%s",errno,strerror(errno));exit(SOCKET_ERR);}lg(Info,"create socket success,listensock_:%d",listensock_);struct sockaddr_in local; //服务器信息memset(&local,0,sizeof(local));local.sin_family=AF_INET;local.sin_port=htons(port_); //用户在构建服务器时就需要告诉我inet_aton(ip_.c_str(),&(local.sin_addr));local.sin_addr.s_addr=INADDR_ANY; //或者写成0if(bind(listensock_,(const sockaddr*)&local,sizeof(local))<0){lg(Fatal,"bind error,errno:%d,errrstring:%s",errno,strerror(errno));exit(BIND_ERR);}lg(Info,"bind success");//和UDP不一样的地方，设为监听状态 Tcp是面向链接的，服务器一般是比较被动的。服务器一直处于一种，一直在等待连接到来的状态if(listen(listensock_,backlog)<0){lg(Fatal,"errno:%d,errrstring:%s",errno,strerror(errno));exit(Listen_ERR);}}// void Service(int sockfd,const std::string &clientip,uint16_t &clientport)// {//     char buffer[4096];//     //测试代码：你给我发什么我就给你响应什么//     while(true)//     {//         ssize_t n=read(sockfd,buffer,sizeof(buffer));//         if(n>0)//         {//             buffer[n]=0;//             std::cout<<"client say#"<<buffer<<std::endl;//             std::string echo_string="tpserver echo#";//             echo_string+=buffer;//             write(sockfd,echo_string.c_str(),echo_string.size()); //再写回去//         }//         else if(n==0)//         {//             //lg(Info,"%s:%d quit,server close sockfd:%d",clientip,clientport,sockfd);//             break;//         }//         else//         {//             lg(Warning,"read Error...,sockfd:%d,client ip:%s,client port:%d",sockfd,clientip.c_str(),clientport);//         }//     }// }// static void* routine(void *args)//静态函数，把this传进来// {//     pthread_detach(pthread_self());//把自己设置为分离状态,主线程一直再获取新连接，创建出线程就不管了，让新线程进行任务处理//     ThreadData *td=static_cast<ThreadData *>(args);//     td->tsvr->Service(td->sockfd,td->clientip,td->clientport);//由该线程提供服务//     delete td;//提供完服务，申请的堆空间释放掉//     return nullptr;// }void Start(){signal(SIGPIPE,SIG_IGN);//防止出现写入的时候，向一个已经关闭的文件描述符写入的时候，此时连接没有意义，这时写时，os直接SIGPIPE掉ThreadPool<Task>::GetInstance()->Start();//启动线程池lg(Info, "tcpserver is running....");while (true){// 1.获取新连接struct sockaddr_in client;socklen_t len = sizeof(client);int sockfd = accept(listensock_, (struct sockaddr *)&client, &len);if (sockfd < 0){lg(Warning, "errno:%d,errrstring:%s", errno, strerror(errno));//获取连接失败，就直接再去获取continue;}//到底是谁连接的我uint16_t clientport=ntohs(client.sin_port); //网络转主机char clientip[32];inet_ntop(AF_INET,&(client.sin_addr),clientip,sizeof(clientip));//把客户端的ip存到ipstr中//2.根据新连接进行通信//lg(Info,"get a new Link...,sockfd:%d,client ip:%s,client port:%d",sockfd,ip,clientport);//version 1// Service(sockfd,ip,clientport);//拿到客户端的端口和ip// close(sockfd);//version 2 --多进程版,因为创建一个进程成本太高了// pid_t id=fork();// if(id==0)// {//     close(listensock_);//     if(fork()>0) exit(0);//     //子进程 什么都可以看到//     Service(sockfd,ip,clientport);//孙子进程，wait立马返回，父进程和孙子进程并发访问，不用管孙子，不用等孙子，儿子已经挂了，孙子会被系统领养//     close(sockfd);//     exit(0);// }// close(sockfd);// //父进程继续获取新连接 打开文件描述符，打开之后交给子进程，自己就关掉了，如果不关，系统中会有非常多的文件没有关闭// pid_t rid=waitpid(id,nullptr,0);// (void)rid;//version 3 多线程版本// ThreadData *td=new ThreadData(sockfd,ip,clientport,this);//this把当前对象传进来// pthread_t tid;// pthread_create(&tid,nullptr,routine,td);//version 4 线程池版Task t(sockfd,clientip,clientport);ThreadPool<Task>::GetInstance()->Push(t);}}~TcpServer(){}; 
private:int listensock_;uint16_t port_;std::string ip_;
};

ThreadPool.hpp
#pragma once#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <pthread.h>
#include <unistd.h>struct ThreadInfo
{pthread_t tid;std::string name;
};static const int defalutnum = 10;template <class T>
class ThreadPool
{
public:void Lock(){pthread_mutex_lock(&mutex_);}void Unlock(){pthread_mutex_unlock(&mutex_);}void Wakeup(){pthread_cond_signal(&cond_);}void ThreadSleep(){pthread_cond_wait(&cond_, &mutex_);}bool IsQueueEmpty(){return tasks_.empty();}std::string GetThreadName(pthread_t tid){for (const auto &ti : threads_){if (ti.tid == tid)return ti.name;}return "None";}public:static void *HandlerTask(void *args){ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);std::string name = tp->GetThreadName(pthread_self());while (true){tp->Lock();while (tp->IsQueueEmpty()){tp->ThreadSleep();}T t = tp->Pop();tp->Unlock();t();}}void Start(){int num = threads_.size();for (int i = 0; i < num; i++){threads_[i].name = "thread-" + std::to_string(i + 1);pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);}}T Pop(){T t = tasks_.front();tasks_.pop();return t;}void Push(const T &t){Lock();tasks_.push(t);Wakeup();Unlock();}static ThreadPool<T> *GetInstance(){if (nullptr == tp_) // ???{pthread_mutex_lock(&lock_);if (nullptr == tp_){std::cout << "log: singleton create done first!" << std::endl;tp_ = new ThreadPool<T>();}pthread_mutex_unlock(&lock_);}return tp_;}private:ThreadPool(int num = defalutnum) : threads_(num){pthread_mutex_init(&mutex_, nullptr);pthread_cond_init(&cond_, nullptr);}~ThreadPool(){pthread_mutex_destroy(&mutex_);pthread_cond_destroy(&cond_);}ThreadPool(const ThreadPool<T> &) = delete;const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
private:std::vector<ThreadInfo> threads_;std::queue<T> tasks_;pthread_mutex_t mutex_;pthread_cond_t cond_;static ThreadPool<T> *tp_;static pthread_mutex_t lock_;
};template <class T>
ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;template <class T>
pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

TcpClient.cc
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <cstring>
//./tcpclient serverip serverport
void Usage(const std::string &proc)
{std::cout << "\n\rUsage: " << proc << " port[1024+]\n" << std::endl;
}
int main(int argc,char* argv[])
{if(argc!=3){Usage(argv[0]);exit(0);}std::string serverip = argv[1];uint16_t serverport = std::stoi(argv[2]);struct sockaddr_in server;memset(&server, 0, sizeof(server));server.sin_family = AF_INET;server.sin_port = htons(serverport);inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr)); // 字符串转为in_addrwhile (true)                                              // 每次翻译的时候都要重新建立连接，因为服务器每次只给我提供一次服务{int cnt = 5;int isreconnect = false;int sockfd = 0;sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0){std::cerr << "socket error" << std::endl;return 1;}do{// tcp客户端要不要bind,要不要显示的bind?// 客户端需要绑定，不需要显示的绑定，将来再通信时需要端口号和ip标识自己的唯一性，当发出消息的时候，服务器才能把消息转过来，但是对于客户端来说// 端口号具体是几不重要，唯一就行，由os随机选择，根据你的需要随机选中，UDP首次发送数据的时候// 客户端向服务器发起连接,TCP中客户端发起connect时，进行自动随机bind,这个函数最后几个参数是要知道服务器的ipint n = connect(sockfd, (struct sockaddr *)&server, sizeof(server));if (n < 0){std::cerr << "connect error" << std::endl;isreconnect=true;cnt--;return 2;}else{break;}}while(cnt&&isreconnect);if(cnt==0){std::cerr<<"user offline..."<<std::endl;break;}//上面的while循环是连接，下面的while是提供服务// while(true)// {std::string message;// 连接成功，可以直接发消息std::cout << "Please enter@" << std::endl;std::getline(std::cin, message);int n = write(sockfd, message.c_str(), message.size());if (n < 0){std::cerr << "write error" << std::endl;break;}// 收到服务器消息char inbuffer[4096];n = read(sockfd, inbuffer, sizeof(inbuffer));if (n > 0){inbuffer[n] = 0;std::cout << inbuffer << std::endl;break;}close(sockfd);}// }return 0;
}

Main.cc
#include"TcpServer.hpp"
#include<iostream>
#include<memory>
#include <pthread.h>void Usage(std::string proc)
{std::cout << "\n\rUsage: " << proc << " port[1024+]\n" << std::endl;
};
//./tcpserver 8080
int main(int argc,char** argv)
{if(argc!=2){Usage(argv[0]);exit(1);}uint16_t port=std::stoi(argv[1]);std::unique_ptr<TcpServer>tcp_svr(new TcpServer(port));tcp_svr->InitServer();tcp_svr->Start();return 0;
}

Task.hpp
#pragma once
#include <iostream>
#include <string>
#include<unistd.h>
#include <unordered_map>
#include"Log.hpp"
#include "Init.hpp"
extern Log lg;
Init init;
class Task
{
public:Task(int sockfd, const std::string &clientip, uint16_t &clientport) : sockfd_(sockfd), clientip_(clientip), clientport_(clientport){}void run(){char buffer[4096];ssize_t n = read(sockfd_, buffer, sizeof(buffer));if (n > 0){buffer[n] = 0;std::cout << "client key#" << buffer << std::endl;std::string echo_string=init.translation(buffer);write(sockfd_, echo_string.c_str(), echo_string.size()); // 再写回去if(n<0){lg(Warning,"write error,errno:%d,errstring:%s",errno,strerror(errno));}}else if (n == 0){// lg(Info,"%s:%d quit,server close sockfd:%d",clientip,clientport,sockfd);//break;}else{lg(Warning, "read Error...,sockfd:%d,client ip:%s,client port:%d", sockfd_, clientip_.c_str(), clientport_);}//只处理一次close(sockfd_);}void operator ()(){run();}~Task(){}private:int sockfd_;std::string clientip_;uint16_t clientport_;
};

Log.hpp
#pragma once#include <iostream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>#define SIZE 1024#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4#define Screen 1
#define Onefile 2
#define Classfile 3#define LogFile "log.txt"class Log
{
public:Log(){printMethod = Screen;path = "./log/";}void Enable(int method){printMethod = method;}std::string levelToString(int level){switch (level){case Info:return "Info";case Debug:return "Debug";case Warning:return "Warning";case Error:return "Error";case Fatal:return "Fatal";default:return "None";}}void printLog(int level, const std::string &logtxt){switch (printMethod){case Screen:std::cout << logtxt << std::endl;break;case Onefile:printOneFile(LogFile, logtxt);break;case Classfile:printClassFile(level, logtxt);break;default:break;}}void printOneFile(const std::string &logname, const std::string &logtxt){std::string _logname = path + logname;int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666); // "log.txt"if (fd < 0)return;write(fd, logtxt.c_str(), logtxt.size());close(fd);}void printClassFile(int level, const std::string &logtxt){std::string filename = LogFile;filename += ".";filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"printOneFile(filename, logtxt);}~Log(){}void operator()(int level, const char *format, ...){time_t t = time(nullptr);struct tm *ctime = localtime(&t);char leftbuffer[SIZE];snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(),ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,ctime->tm_hour, ctime->tm_min, ctime->tm_sec);va_list s;va_start(s, format);char rightbuffer[SIZE];vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);va_end(s);// 格式：默认部分+自定义部分char logtxt[SIZE * 2];snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);// printf("%s", logtxt); // 暂时打印printLog(level, logtxt);}private:int printMethod;std::string path;
};

Init.hpp
#pragma once
#include<iostream>
#include<string>
#include <unordered_map>
#include <fstream>
#include "Log.hpp"
extern Log lg;
const std::string dictname="./dict.txt";
const std::string sep=":";
//apple:苹果
static bool Split(std::string &s,std::string *part1,std::string *part2)
{auto pos=s.find(sep);if(pos==std::string::npos) return false;*part1=s.substr(0,pos);*part2=s.substr(pos+1);//从pos到结尾
}
class Init
{
public:Init(){std::ifstream in(dictname);if(!in.is_open()){lg(Fatal,"ifstream open %s error",dictname.c_str());exit(1);}std::string line;while(std::getline(in,line)){std::string part1,part2;Split(line,&part1,&part2);dict.insert({part1,part2});}in.close();}std::string translation(const std::string &key){auto iter=dict.find(key);if(iter==dict.end()) return  "Unknow";else return iter->second;}
private:std::unordered_map<std::string,std::string> dict;
};

Makefile
.PHONY:all
all:tcpserver tcpclient
tcpserver:Main.ccg++ -o $@ $^ -std=c++11 -lpthread
tcpclient:TcpClient.ccg++ -o $@ $^ -std=c++11
.PHONY:clean
clean:rm -f tcpserver tcpclient

4、理解前台进程和后台进程

在操作系统中，程序可以在两种模式下运行：前台和后台。

 4.1什么叫前台进程？

        前台进程是与用户直接交互的进程。当你在终端中运行程序时（例如，执行./process），它默认是在前台运行，这意味着它会占用终端并接收来自键盘的输入。这种进程会阻塞终端输入，直到进程结束，所以在它运行期间，像ls或pwd这样的命令通常不会有反应。

下面是一个简单的C++程序运行在前台的示例：

process.cc
#include<iostream>
#include<string>
#include<unistd.h>
int main()
{while(true){std::cout<<"hello..."<<std::endl;sleep(1);}return 0;
}

 

4.2后台进程

有时，你可能希望程序在后台运行，以便不阻塞你的终端。这时你可以在命令后面加上符号&，例如： 

./process &

这样，程序就会在后台运行，你可以继续使用终端执行其他命令。

4.3切换前后台

如果需要将一个后台进程切换到前台，可以使用fg命令。例如fg 1会将后台任务列表中的第一个任务移至前台。  把后台进程提到前台   fg 1

 所以什么叫做前台，什么叫后台？

谁拥有键盘文件