您现在的位置是：首页 >其他 >【网络编程】实现UDP/TCP客户端、服务器网站首页其他

【网络编程】实现UDP/TCP客户端、服务器

蒋灵瑜的笔记本 2024-06-17 11:25:12
简介【网络编程】实现UDP/TCP客户端、服务器

目录

一、UDP

1、Linux客户端、服务器

1.1udpServer.hpp

1.2udpServer.cc

1.3udpClient.hpp

1.4udpClient.cc

1.5onlineUser.hpp

2、Windows客户端

二、TCP

1、单进程版的TCP客户端、服务器

1.1tcpServer.hpp

1.2tcpServer.cc

1.3tcpClient.hpp

1.4tcpClient.cc

1.5log.hpp

2、多进程版的TCP客户端、服务器

3、多线程版的TCP客户端、服务器

4、线程池版的TCP客户端、服务器

4.1tcpServer.hpp

4.2ThreadPool.hpp 

4.3Task.hpp

5、守护进程+多线程版的TCP客户端、服务器

5.1daemon.hpp

5.2tcpServer.cc

UDP/TCP客户端、服务器代码可参考本人gitee

UDP/TCP套接字的创建流程可参考此处

一、UDP

1、Linux客户端、服务器

1.1udpServer.hpp

#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <arpa/inet.h>
#include <strings.h>
#include <functional>
namespace Server
{
    const static string defaultIp="0.0.0.0";//缺省的IP
    const static int gnum=1024;
    typedef function<void(int,string,uint16_t,string)> func_t;
    enum 
    {
        USAGE_ERR=1,
        SOCKET_ERR,
        BIND_ERR,
        OPEN_ERR,
    };
    class udpServer
    {
    public:
        udpServer(const func_t& callback,const uint16_t& port,const string& ip=defaultIp)
        :_callback(callback)//udpServer.cc传入的对客户端数据处理的函数
        ,_port(port)
        ,_ip(ip)
        ,_sockfd(-1)
        {}
        void initServer()
        {
             //1、创建socket
            _sockfd=socket(AF_INET,SOCK_DGRAM,0);//网络通信+数据报
            if(-1==_sockfd)
            {
                cout<<"socket error"<<errno<<":"<<strerror(errno)<<endl;
                exit(SOCKET_ERR);
            }
            cout<<"socket success"<<":"<<_sockfd<<endl;
            //2、绑定IP和端口号
            struct sockaddr_in local;
            bzero(&local,sizeof(local));//将一段内存初始化为全0
            local.sin_family=AF_INET;//协议族设置为网络通信
            local.sin_port=htons(_port);//设置端口号,需要转为大端，主机转网络
            local.sin_addr.s_addr=inet_addr(_ip.c_str());//将IP字符串转uint32_t的同时转为网络字节序
            //local.sin_addr.s_addr=htonl(INADDR_ANY);//INADDR_ANY就是0，表明任何IP都可以访问这个服务器的_port端口
            int n=bind(_sockfd,(struct sockaddr*)&local,sizeof(local));
            if(-1==n)
            {
                cout<<"bind error"<<errno<<":"<<strerror(errno)<<endl;
                exit(BIND_ERR);
            }
        }
        void start()
        {
            char buffer[gnum];
            while(1)
            {
                //循环读取数据
                struct sockaddr_in local;//输出型参数
                socklen_t len=sizeof(local);//必填
                size_t s=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&local,&len);//阻塞式读取
                //这里需要关心1、数据是什么2、数据是谁发的
                if(s>0)
                {
                    buffer[s]=0;//加上''
                    //1、这是从网络读出来的IP，需要由网络字节序转主机字节序2、整数转点分十进制IP,用inet_ntoa进行转换
                    string clientIp=inet_ntoa(local.sin_addr);//将32位IPv4地址（in_addr结构体）转换成点分十进制字符串形式的IP地址
                    uint16_t clientPort=ntohs(local.sin_port);//一样需要转换字节序
                    string message=buffer;
                    cout<<clientIp<<"["<<clientPort<<"]#"<<message<<endl;
                    //对数据进行处理
                    _callback(_sockfd,clientIp,clientPort,message);
                }
            }
        }
        ~udpServer()
        {

        }
    private:
        uint16_t _port;//端口号
        string _ip;//IP地址(服务器不建议固定的绑定一个IP地址，因为服务器需要接收所有的IP)
        int _sockfd;//套接字文件描述符
        func_t _callback;//回调函数
    };
}

1.2udpServer.cc

#include <memory>
#include <unordered_map>
#include <fstream>
#include <signal.h>
using namespace std;
#include "udpServer.hpp"
#include "onlineUser.hpp"
using namespace Server;
// const std::string dictTxt="./dict.txt";
// unordered_map<string,string> dict;//字典
// std::string key,value;

static void Usage(string proc)
{
    cout<<"Usage:
	"<<proc<<"local_ip local_port

";
}

// static bool cutString(const string& target,string* key,string* value,const string& sep)//字符串截取
// {
//     //string sep=":";
//     auto pos=target.find(sep,0);
//     if(pos==string::npos)
//     {
//         return false;
//     }
//     *key=target.substr(0,pos);
//     *value=target.substr(pos+sep.size());
//     return true;
// }
// static void initDict()//文件操作
// {
//     ifstream in(dictTxt,std::ios_base::binary);
//     if(!in.is_open())//如果文件打开失败
//     {
//         cerr<<"open file"<<dictTxt<<"error"<<endl;
//         exit(OPEN_ERR);
//     }
//     string line;
//     while(getline(in,line))
//     {
//         if(cutString(line,&key,&value,":"))//如果截取成功
//         {
//             dict.insert(make_pair(key,value));//dict.insert(key,value);
//         }
//         else //截取失败
//         {
//             //...
//         }
//     }
//     in.close();
//     cout<<"load dict success"<<endl;
// }
// static void debugPrint()//测试打印函数
// {
//     for(auto& dt:dict)
//     {
//         cout<<dt.first<<"/"<<dt.second<<endl;
//     }
// }
// //客户端单词翻译代码
// void handMessage(int sockfd,string clientIp,uint16_t clientPort,string message)
// {
//     //对客户端的信息进行特定的业务处理，实现了server通信和业务的解耦
//     string response_message;//将查找的字符串保存至此处
//     unordered_map<string,string>::iterator iter=dict.find(message);
//     if(iter==dict.end())
//     {
//         response_message="unknow";
//     }
//     else
//         response_message=iter->second;
//     //服务端向客户端回发数据
//     struct sockaddr_in client;
//     bzero(&client,sizeof(client));
//     client.sin_family=AF_INET;
//     client.sin_addr.s_addr=inet_addr(clientIp.c_str());
//     client.sin_port=htons(clientPort);
//     sendto(sockfd,response_message.c_str(),response_message.size(),0,(struct sockaddr*)&client,sizeof(client));
// }
// //解析客户端上传的命令
// void execCommand(int sockfd,string clientIp,uint16_t clientPort,string cmd)
// {
//     //对客户端的信息进行特定的业务处理，实现了server通信和业务的解耦
//     auto end=cmd.find("rm");
//     if(end!=string::npos)
//     {
//         cerr<<clientIp<<":"<<clientPort<<"非法操作"<<cmd<<endl;
//         return;
//     }
//     string response_message;//将客户端上传的指令保存至此处
//     FILE* fp=popen(cmd.c_str(),"r");
//     if(fp==nullptr)
//     {
//         response_message=cmd+" exec failed";
//     }
//     char line[1024];
//     while(fgets(line,sizeof(line),fp))
//     {
//         response_message+=line;//读出客户端传入的指令
//     }
//     pclose(fp);
//     //服务端向客户端回发数据
//     struct sockaddr_in client;
//     bzero(&client,sizeof(client));
//     client.sin_family=AF_INET;
//     client.sin_addr.s_addr=inet_addr(clientIp.c_str());
//     client.sin_port=htons(clientPort);
//     sendto(sockfd,response_message.c_str(),response_message.size(),0,(struct sockaddr*)&client,sizeof(client));
// }
//聊天室
OnlineUser olUser;
void routeMessage(int sockfd,string clientIp,uint16_t clientPort,string message)
{
    //上线就新增，下线就减掉
    if(message=="online")
    {
        olUser.addUser(clientIp,clientPort);
    }
    if(message=="offline")
    {
        olUser.delUser(clientIp,clientPort);
    }
    if(olUser.isOnline(clientIp,clientPort))
    {
        //广播消息
        olUser.broadcastMessage(sockfd,clientIp,clientPort,message);
    }
    else
    {
        //服务端向客户端回发数据
        string response_message="请先运行online";
        struct sockaddr_in client;
        bzero(&client,sizeof(client));
        client.sin_family=AF_INET;
        client.sin_addr.s_addr=inet_addr(clientIp.c_str());
        client.sin_port=htons(clientPort);
        sendto(sockfd,response_message.c_str(),response_message.size(),0,(struct sockaddr*)&client,sizeof(client));
    }
}
// void reload(int signo)//热加载回调函数
// {
//     (void)signo;
//     initDict();
// }
int main(int argc,char* argv[])//./udpServer port
{
    if(argc!=2)//判断外部传入的参数是否为3
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port=atoi(argv[1]);//需要转uint16_t整型

    // signal(2,reload);//发送信号，实现文本的热加载
    // initDict();
    //std::unique_ptr<udpServer> usvr(new udpServer(handMessage,port));//在线翻译
    //std::unique_ptr<udpServer> usvr(new udpServer(execCommand,port));//指令解析
    std::unique_ptr<udpServer> usvr(new udpServer(routeMessage,port));//聊天室
    usvr->initServer();
    usvr->start();
    return 0;
}

1.3udpClient.hpp

#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <arpa/inet.h>
#include <strings.h>
namespace Client
{
    using namespace std;
    class udpClient
    {
    public:
        udpClient(const string& serverIp,const uint16_t& serverPort)
        :_sockfd(-1)
        ,_serverPort(serverPort)
        ,_serverIp(serverIp)
        {}
        void initClient()
        {
            //创建socket
            _sockfd=socket(AF_INET,SOCK_DGRAM,0);
            if(-1==_sockfd)
            {
                cout<<"socket error"<<errno<<":"<<strerror(errno)<<endl;
                exit(2);
            }
            cout<<"socket syuccess"<<":"<<_sockfd<<endl;
        }
        static void* readMessage(void* args)//类内创建线程,有个this指针干扰
        {
            int sockfd=*static_cast<int*>(args);
            pthread_detach(pthread_self());
            while(1)
            {
                //接收服务端发送的数据
                char buffer[1024];
                struct sockaddr_in temp;
                socklen_t len=sizeof(temp);
                size_t s=recvfrom(sockfd,buffer,sizeof(buffer),0,(struct sockaddr*)&temp,&len);
                if(s>0)
                {
                    buffer[s]=0;//字符串以''结尾
                }
                cout<<buffer<<endl;
            }
            return nullptr;
        }
        void run()
        {
            pthread_create(&_reader,nullptr,readMessage,(void*)&_sockfd);
            struct sockaddr_in server;
            memset(&server,sizeof(server),0);//初始化为全0
            server.sin_family=AF_INET;
            server.sin_addr.s_addr=inet_addr(_serverIp.c_str());
            server.sin_port=htons(_serverPort);//主机转网络
            string message;
            char cmdline[1024];
            while(1)
            {
                //cerr<<"Please Enter#";
                // cin>>message;
                fprintf(stderr,"Enter#");
                fflush(stderr);
                fgets(cmdline,sizeof(cmdline),stdin);
                cmdline[strlen(cmdline)-1]=0;
                message=cmdline;
                //发送数据,sendto的时候，操作系统会帮我们自动绑定客户端端口+IP地址
                sendto(_sockfd,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));
                
            }
        }
        ~udpClient()
        {}
    private:
        int _sockfd;
        uint16_t _serverPort;
        string _serverIp;
        pthread_t _reader;//读线程
    };
}

1.4udpClient.cc

#include <memory>
#include "udpClient.hpp"
using namespace Client;
static void Usage(string proc)
{
    cout<<"Usage:
	"<<proc<<"server_ip server_port

";
}
int main(int argc,char* argv[])//./udpClient server_ip server_port
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(1);
    }
    string serverIp=argv[1];
    uint16_t serverPort=atoi(argv[2]);
    unique_ptr<udpClient> ucli(new udpClient(serverIp,serverPort));
    ucli->initClient();
    ucli->run();
    return 0;
}

1.5onlineUser.hpp

#pragma once
#include <iostream>
#include <string>
#include <unordered_map>
#include <sys/types.h>
#include <sys/socket.h>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <arpa/inet.h>
using namespace std;
class User
{
public:
    User(const string& ip,const uint16_t& port)
        :_ip(ip)
        ,_port(port)
    {

    }
    ~User()
    {}
    string ip()
    {
        return _ip;
    }
    uint16_t port()
    {
        return _port;
    }
private:
    string _ip;//用户IP
    uint16_t _port;//用户端口号

};
class OnlineUser
{
public:
    OnlineUser()
    {}
    ~OnlineUser()
    {}
    void addUser(const string& ip,const uint16_t& port)//新增用户
    {
        string id=ip+"-"+to_string(port);
        users.insert(make_pair(id,User(ip,port)));
    }
    void delUser(const string& ip,const uint16_t& port)//删除用户
    {
        string id=ip+"-"+to_string(port);
        users.erase(id);
    }
    bool isOnline(const string& ip,const uint16_t& port)//是否在线
    {
        string id=ip+"-"+to_string(port);
        return users.find(id)==users.end()?false:true;
    }
    void broadcastMessage(int sockfd,const string& ip,const uint16_t& port,const string& message)//给所有的user广播消息
    {
        for(auto& user:users)
        {
            //服务端向客户端回发数据
            struct sockaddr_in client;
            bzero(&client,sizeof(client));
            client.sin_family=AF_INET;
            client.sin_addr.s_addr=inet_addr(user.second.ip().c_str());
            client.sin_port=htons(user.second.port());
            string s=ip+"_"+to_string(port)+"# ";//id+"#"
            s+=message;
            sendto(sockfd,s.c_str(),s.size(),0,(struct sockaddr*)&client,sizeof(client));
        }
    }
private:
    unordered_map<string,User> users;//string:id=ip+"-"+to_string(port);User：User类
};

2、Windows客户端

        可先让上方Linux服务器先运行起来，再让Windows客户端连接上该服务端，实现网络通信。

#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <iostream>
#include <WinSock2.h>
#include <string>
#include <cstring>
#pragma comment(lib,"ws2_32.lib")
using namespace std;
uint16_t serverPort = 8080;
string serverIp = "43.XXX.105.XX";//你的云服务器IP
#define NUM 1024
int main()
{
	WSAData wsd;
	//启动Winsock
	if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
	{
		cout << "WSAStartUp Error = " << WSAGetLastError() << endl;
		return -1;
	}
	else
	{
		cout << "WSAStartup Success" << endl;
	}
	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);//创建套接字
	if (sock == SOCKET_ERROR)
	{
		cout<<"socket Error = "<< WSAGetLastError() << endl;
		return -2;
	}
	else
	{
		cout << "socket Success" << endl;
	}
	struct sockaddr_in server;
	memset(&server, 0, sizeof(server));
	server.sin_addr.s_addr = inet_addr(serverIp.c_str());
	server.sin_family = AF_INET;
	server.sin_port = htons(serverPort);
	string line;
	char buffer[NUM];
	while (1)
	{
		//发送数据
		cout << "Please Enter#";
		getline(cin, line);
		int n = sendto(sock, line.c_str(), line.size(), 0, (struct sockaddr*)&server, sizeof(server));
		if (n < 0)
		{
			cerr << "sendto Error" << endl;
			break;
		}
		cout << "发送成功" << endl;
		//接收数据
		buffer[0] = 0;//C式清空数组
		struct sockaddr_in peer;
		int len = (int)sizeof(peer);
		n = recvfrom(sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
		if (n > 0)
		{
			buffer[n] = 0;
			cout << "server 返回的消息是" << buffer << endl;
		}
		else break;
	}
	closesocket(sock);//关闭套接字
	WSACleanup();
	return 0;
}

二、TCP

1、单进程版的TCP客户端、服务器

        单线程会一直在ServerIO读取写入数据，为一个客户端服务，如果此时连接的客户端不止一个，其他客户端发送的信息将不会被显示。需要使用多线程或多进程解决。

1.1tcpServer.hpp

#pragma once
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <cstring>
#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;//最大连接数=5+1
    const static std::string defaultIp="0.0.0.0";//缺省的IP
    class TcpServer
    {
    public:
        TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
            :_listenSocket(-1)
            ,_port(port)   
            ,_ip(ip)
        {

        }
        void InitServer()//初始化服务器
        {
            //1、创建sockrt套接字
            _listenSocket=socket(AF_INET,SOCK_STREAM,0);
            if(_listenSocket<0)
            {
                LogMessage(FATAL,"create socket error");
                exit(SOCKET_ERR);
            }
            LogMessage(NORMAL,"create socket success");
            //2、绑定端口号+ip地址
            struct sockaddr_in local;
            memset(&local,0,sizeof(local));
            local.sin_addr.s_addr=inet_addr(_ip.c_str());
            local.sin_family=AF_INET;
            local.sin_port=htons(_port);
            if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
            {
                LogMessage(FATAL,"bind socket error");
                exit(BIND_ERR);
            }
            LogMessage(NORMAL,"bind socket success");
            //3、设置监听状态
            if(-1==listen(_listenSocket,gbacklog))
            {
                LogMessage(FATAL,"listen socket error");
                exit(LISTEN_ERR);
            }
            LogMessage(NORMAL,"listen socket success");
        }
        void Start()//启动服务器
        {
            while(1)
            {
                //4、服务器获取客户端连接请求
                struct sockaddr_in peer;//输出型参数，拿到客户端的信息
                socklen_t len=sizeof(peer);
                int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
                if(-1==sock)      
                {
                    LogMessage(ERROR,"accept error,next");
                    continue;
                }           
                LogMessage(NORMAL,"accept a new link success");
                //5、使用accept的返回值sock进行通信，均为文件操作
                ServerIO(sock);
                close(sock);//必须关闭使用完毕的sock，否则文件描述符泄漏
            }
        }
        void ServerIO(int sock)
        {
            char buffer[1024];
            while(1)
            {
                //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
                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());
                }
                else if(0==n)//服务器read返回值为0，说明客户端关闭了
                {
                    LogMessage(NORMAL,"client quit,server quit");
                    break;
                }
            }
        }
        ~TcpServer()
        {}
    private:
        int _listenSocket;//监听客户端的连接请求，不用于数据通信
        uint16_t _port;//服务器端口号
        std::string _ip;//服务器ip地址
    };
}

1.2tcpServer.cc

#include "tcpServer.hpp"
#include "memory"
using namespace Server;
static void Usage(std::string proc)
{
    std::cout<<"Usage:
	"<<proc<<"serverPort

";
}
//./tcpServer local_port
int main(int argc,char* argv[])
{
    if(argc!=2)//判断外部传入的参数是否为2
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port=std::stoi(argv[1]);
    std::unique_ptr<TcpServer> tsvr(new TcpServer(port));
    tsvr->InitServer();
    tsvr->Start();
    return 0;
}

1.3tcpClient.hpp

#pragma once
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <cstring>
#define NUM 1024
class TcpClient
{
public:
    TcpClient(const std::string& serverIp,const uint16_t& serverPort)
        :_serverIp(serverIp)
        ,_serverPort(serverPort)
        ,_sock(-1)
    {

    }
    void InitClient()
    {
        //1、创建套接字
        _sock=socket(AF_INET,SOCK_STREAM,0);
        if(_sock<0)
        {   
            std::cerr<<"cerete socket err"<<std::endl;
            exit(2);
        }
        //2、客户端需要bind，但是客户端的绑定不需要我们自己写，操作系统会去绑定；（无需程序员bind）
    }
    void Start()
    {
        //3、客户端发起连接
        struct sockaddr_in server;
        memset(&server,0,sizeof(server));
        server.sin_addr.s_addr=inet_addr(_serverIp.c_str());
        server.sin_family=AF_INET;
        server.sin_port=htons(_serverPort);
        if(connect(_sock,(struct sockaddr*)&server,sizeof(server))<0)//连接失败
        {
            std::cerr<<"sock connect error"<<std::endl;
        }
        else//连接成功
        {
            //4、客户端发送/接收消息，文件操作
            std::string msg;
            while(1)
            {
                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;//客户端套接字
    uint16_t _serverPort;//服务器端口号
    std::string _serverIp;//服务器ip
};

1.4tcpClient.cc

#include "tcpClient.hpp"
#include <memory>
static void Usage(std::string proc)
{
    std::cout<<"Usage:
	"<<proc<<"local_ip local_port

";
}
//./tcpClient serverIp serverPort
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string serverIp=argv[1];
    uint16_t serverPort=std::stoi(argv[2]);
    std::unique_ptr<TcpClient> tcli(new TcpClient(serverIp,serverPort));
    tcli->InitClient();
    tcli->Start();
    return 0;
}

1.5log.hpp

#pragma once
#include <iostream>
#include <string>
#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]
    std::cout<<message<<std::endl;
}

2、多进程版的TCP客户端、服务器

        更换tcpServer.hpp即可，其他文件和单进程版一样。

#pragma once
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <cstring>
#include <cstdlib>
#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;//最大连接数=5+1
    const static std::string defaultIp="0.0.0.0";//缺省的IP
    class TcpServer
    {
    public:
        TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
            :_listenSocket(-1)
            ,_port(port)   
            ,_ip(ip)
        {

        }
        void InitServer()//初始化服务器
        {
            //1、创建sockrt套接字
            _listenSocket=socket(AF_INET,SOCK_STREAM,0);
            if(_listenSocket<0)
            {
                LogMessage(FATAL,"create socket error");
                exit(SOCKET_ERR);
            }
            LogMessage(NORMAL,"create socket success");
            //2、绑定端口号+ip地址
            struct sockaddr_in local;
            memset(&local,0,sizeof(local));
            local.sin_addr.s_addr=inet_addr(_ip.c_str());
            local.sin_family=AF_INET;
            local.sin_port=htons(_port);
            if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
            {
                LogMessage(FATAL,"bind socket error");
                exit(BIND_ERR);
            }
            LogMessage(NORMAL,"bind socket success");
            //3、设置监听状态
            if(-1==listen(_listenSocket,gbacklog))
            {
                LogMessage(FATAL,"listen socket error");
                exit(LISTEN_ERR);
            }
            LogMessage(NORMAL,"listen socket success");
        }
        void Start()//启动服务器
        {
            while(1)
            {
                //4、服务器获取客户端连接请求
                struct sockaddr_in peer;//输出型参数，拿到客户端的信息
                socklen_t len=sizeof(peer);
                int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
                if(-1==sock)      
                {
                    LogMessage(ERROR,"accept error,next");
                    continue;
                }           
                LogMessage(NORMAL,"accept a new link success");
                // //5、使用accept的返回值sock进行通信，均为文件操作
                pid_t id=fork();
                if(id==0)//子进程
                {
                    close(_listenSocket);//子进程的
                    if(fork()>0) exit(0);//让子进程退出，孙子进程成为孤儿进程，交给1号进程托管回收其退出资源
                    ServerIO(sock);
                    close(sock);//必须关闭使用完毕的sock，否则文件描述符泄漏（虽然下一句代码exit(0),孙子进程退出也会释放文件描述符，最好还是手动关一下）
                    exit(0);
                }
                close(sock);//这是用于通信的套接字fd，父进程和孙子进程都有这个文件描述符，父进程关了，该文件描述符引用技术-1，直至孙子进程退出，该fd才会减为0，关闭
                //父进程
                //waitpid()
                pid_t ret=waitpid(id,nullptr,0);//这里不能用非阻塞等待，否则父进程先跑去执行其他代码，可能会被卡在accept出不来了（没有新的客户端来连接的话）
                if(ret>0)
                {
                    std::cout<<"waitsucceess"<<ret<<std::endl;
                }
            }
        }       
        void ServerIO(int sock)
        {
            char buffer[1024];
            while(1)
            {
                //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
                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());
                }
                else if(0==n)//服务器read返回值为0，说明客户端关闭了
                {
                    LogMessage(NORMAL,"client quit,server quit");
                    break;
                }
            }
        }
        ~TcpServer()
        {}
    private:
        int _listenSocket;//监听客户端的连接请求，不用于数据通信
        uint16_t _port;//服务器端口号
        std::string _ip;//服务器ip地址
    };
}

区别在于这张图里的代码：

1、close(_listenSocket):关闭子进程的监听fd（虽然手动关不关都行，因为下一句代码就让子进程退出了，最好还是手动关一下）

2、if(fork()>0) exit(0)：让子进程创建孙子进程，子进程退出。提前干掉子进程，这样父进程在外部就可以不用阻塞式等待子进程退出了。同时孙子进程成为孤儿进程，会被1号进程领养，程序员无需关心孤儿进程的退出善后工作。

3、孙子进程close(sock)：必须关闭使用完毕的sock，否则文件描述符泄漏（虽然下一句代码exit(0),孙子进程退出也会释放文件描述符，最好还是手动关一下）

4、父进程close(sock)：这是用于通信的套接字fd，父进程和孙子进程都有这个文件描述符，父进程关了，该文件描述符引用计数-1，直至孙子进程退出，该fd才会减为0，关闭，所以父进程提前关闭该fd不会影响孙子进程。但是这里父进程如果不关，客户端连一个fd+1，存在文件描述符泄露。

5、pid_t ret=waitpid(id,nullptr,0)：这里不能用非阻塞等待，否则父进程先跑去执行其他代码，可能会被卡在accept出不来了（如果没有新的客户端来连接的话，将一直卡在accept）

3、多线程版的TCP客户端、服务器

更换tcpServer.hpp即可，其他文件和单进程版一样。

#pragma once
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <cstring>
#include <cstdlib>
#include <pthread.h>
#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;//最大连接数=5+1
    const static std::string defaultIp="0.0.0.0";//缺省的IP
    class TcpServer;
    struct ThreadData//用于线程函数传参
    {
        ThreadData(TcpServer* self,const int& sock)
            :_self(self)
            ,_sock(sock)
        {}
        TcpServer* _self;//this
        int _sock;//通信fd
    };
    class TcpServer
    {
    public:
        TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
            :_listenSocket(-1)
            ,_port(port)   
            ,_ip(ip)
        {

        }
        void InitServer()//初始化服务器
        {
            //1、创建sockrt套接字
            _listenSocket=socket(AF_INET,SOCK_STREAM,0);
            if(_listenSocket<0)
            {
                LogMessage(FATAL,"create socket error");
                exit(SOCKET_ERR);
            }
            LogMessage(NORMAL,"create socket success");
            //2、绑定端口号+ip地址
            struct sockaddr_in local;
            memset(&local,0,sizeof(local));
            local.sin_addr.s_addr=inet_addr(_ip.c_str());
            local.sin_family=AF_INET;
            local.sin_port=htons(_port);
            if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
            {
                LogMessage(FATAL,"bind socket error");
                exit(BIND_ERR);
            }
            LogMessage(NORMAL,"bind socket success");
            //3、设置监听状态
            if(-1==listen(_listenSocket,gbacklog))
            {
                LogMessage(FATAL,"listen socket error");
                exit(LISTEN_ERR);
            }
            LogMessage(NORMAL,"listen socket success");
        }
        void Start()//启动服务器
        {
            while(1)
            {
                //4、服务器获取客户端连接请求
                struct sockaddr_in peer;//输出型参数，拿到客户端的信息
                socklen_t len=sizeof(peer);
                int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
                if(-1==sock)      
                {
                    LogMessage(ERROR,"accept error,next");
                    continue;
                }           
                LogMessage(NORMAL,"accept a new link success");
                //5、使用accept的返回值sock进行通信，均为文件操作
                //多线程版
                pthread_t tid;
                ThreadData* td=new ThreadData(this,sock);
                pthread_create(&tid,nullptr,threadRoutine,(void*)td);
            }
        }   
        static void* threadRoutine(void* args)
        {
            pthread_detach(pthread_self());//线程分离
            ThreadData* td=static_cast<ThreadData*>(args);
            td->_self->ServerIO(td->_sock);//线程调用服务函数
            close(td->_sock);
            delete td;
            return nullptr;
        }
        void ServerIO(int sock)
        {
            char buffer[1024];
            while(1)
            {
                //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
                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());
                }
                else if(0==n)//服务器read返回值为0，说明客户端关闭了
                {
                    LogMessage(NORMAL,"client quit,server quit");
                    break;
                }
            }
        }
        ~TcpServer()
        {}
    private:
        int _listenSocket;//监听客户端的连接请求，不用于数据通信
        uint16_t _port;//服务器端口号
        std::string _ip;//服务器ip地址
    };
}

        在一个进程中的所有线程都可以访问到文件描述符表，属于共享资源，一个线程所对应的fd在使用完毕后需要进行关闭。

4、线程池版的TCP客户端、服务器

        其他文件和单进程版一样。

4.1tcpServer.hpp

#pragma once
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <cstring>
#include <cstdlib>
#include <pthread.h>
#include "log.hpp"
#include "Task.hpp"
#include "ThreadPool.hpp"
namespace Server
{
    enum 
    {
        USAGE_ERR=1,
        SOCKET_ERR,
        BIND_ERR,
        LISTEN_ERR,
    };
    static const uint16_t gport=8080;//缺省的端口号
    static const int gbacklog=5;//最大连接数=5+1
    const static std::string defaultIp="0.0.0.0";//缺省的IP
    class TcpServer;
    struct ThreadData//用于线程函数传参
    {
        ThreadData(TcpServer* self,const int& sock)
            :_self(self)
            ,_sock(sock)
        {}
        TcpServer* _self;//this
        int _sock;//通信fd
    };
    class TcpServer
    {
    public:
        TcpServer(const uint16_t& port=gport,const std::string& ip=defaultIp )
            :_listenSocket(-1)
            ,_port(port)   
            ,_ip(ip)
        {

        }
        void InitServer()//初始化服务器
        {
            //1、创建sockrt套接字
            _listenSocket=socket(AF_INET,SOCK_STREAM,0);
            if(_listenSocket<0)
            {
                LogMessage(FATAL,"create socket error");
                exit(SOCKET_ERR);
            }
            LogMessage(NORMAL,"create socket success");
            //2、绑定端口号+ip地址
            struct sockaddr_in local;
            memset(&local,0,sizeof(local));
            local.sin_addr.s_addr=inet_addr(_ip.c_str());
            local.sin_family=AF_INET;
            local.sin_port=htons(_port);
            if(bind(_listenSocket,(struct sockaddr*)&local,sizeof(local))<0)
            {
                LogMessage(FATAL,"bind socket error");
                exit(BIND_ERR);
            }
            LogMessage(NORMAL,"bind socket success");
            //3、设置监听状态
            if(-1==listen(_listenSocket,gbacklog))
            {
                LogMessage(FATAL,"listen socket error");
                exit(LISTEN_ERR);
            }
            LogMessage(NORMAL,"listen socket success");
        }
        void Start()//启动服务器
        {
            //4、线程池初始化
            ThreadPool<Task>::getInstance()->run();//线程启动
            while(1)
            {
                //5、服务器获取客户端连接请求
                struct sockaddr_in peer;//输出型参数，拿到客户端的信息
                socklen_t len=sizeof(peer);
                int sock=accept(_listenSocket,(struct sockaddr*)&peer,&len);  
                if(-1==sock)      
                {
                    LogMessage(ERROR,"accept error,next");
                    continue;
                }           
                LogMessage(NORMAL,"accept a new link success");
                ThreadPool<Task>::getInstance()->push(Task(sock,ServerIO));
            }
        }   
        ~TcpServer()
        {}
    private:
        int _listenSocket;//监听客户端的连接请求，不用于数据通信
        uint16_t _port;//服务器端口号
        std::string _ip;//服务器ip地址
    };
}

4.2ThreadPool.hpp 

#pragma once
#include <vector>
#include <queue>
#include <pthread.h>
#include <unistd.h>
#include <mutex>
#include "Thread.hpp"
#include "LockGuard.hpp"
using namespace ThreadNs;
const int gnum =5;

template <class T>//声明
class ThreadPool;

template <class T>
struct ThreadData
{
    ThreadData(ThreadPool<T>* tp,const std::string& s)
    :_threadPool(tp)
    ,_name(s)
    {}
    ThreadPool<T>* _threadPool;
    std::string _name;
};
template <class T>
class ThreadPool
{
private:
    //因为普通成员函数第一个参数是this指针，和回调方法不匹配，故改成static类型
    static void* handlerTask(void* args)//args是ThreadData对象指针
    {
        ThreadData<T>* td=static_cast<ThreadData<T>*>(args);
        while(1)
        {
            T t;
            {   //RAII，出了作用域LockGuard会销毁，将析构锁
                LockGuard lockGuard(td->_threadPool->mutex());//加锁
                while(td->_threadPool->IsQueueEmpty())//如果队列为空，则等待
                {
                    td->_threadPool->ThreadWait();
                }
                //线程能走到这里，说明队列一定有任务给线程
                t=td->_threadPool->Pop();//从队列中取出任务
            }
            t();//Task的operator()
        }
        delete td;//析构ThreadData对象
        return nullptr;
    }
    ThreadPool(const int& num=gnum)
    :_num(num)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_cond,nullptr);
        //创建线程
        for(int i=0;i<_num;++i)
        {
            _threads.push_back(new Thread());
        }
    }
    ThreadPool(const ThreadPool<T>&)=delete;//禁用拷贝构造
    ThreadPool<T>& operator=(const ThreadPool<T>&)=delete;//禁用赋值运算符重载

public://解决静态handlerTask是静态函数的问题，这几个都是偷家函数
    void LockQueue()   {pthread_mutex_lock(&_mutex);}
    void UnLockQueue() {pthread_mutex_unlock(&_mutex);}
    bool IsQueueEmpty(){return _taskQueue.empty();}
    void ThreadWait()  {pthread_cond_wait(&_cond,&_mutex);}
    T Pop()         
    {
        T t=_taskQueue.front();
        _taskQueue.pop();
        return t;
    } 
    pthread_mutex_t* mutex()
    {
        return &_mutex;
    }
public: 
    void run()//线程启动
    {
        for(const auto& t:_threads)
        {
            ThreadData<T>* td=new ThreadData<T>(this,t->threadName());
            t->start(handlerTask,(void*)td);
            std::cout<<t->threadName()<<"start..."<<std::endl;
        }
    }
    void push(const T& in)
    {
        //RAII,出了作用域，锁将会被释放
        LockGuard lockGuard(&_mutex);
        _taskQueue.push(in);
        pthread_cond_signal(&_cond);
        std::cout<<"任务发送成功"<<std::endl;
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
        for(const auto& t:_threads)
        {
            delete t;
        }
    }
    static ThreadPool<T>* getInstance()//这里的static的作用是让这个函数只有一份，获取单例对象。tp是临界资源，需要加锁
    {
        if(nullptr==tp)//因为锁只创建一次，防止线程进来被锁阻塞
        {
            //只进来一次就够了
            _singletonLock.lock();
            if(nullptr==tp)//说明对象还没有被创建
            {
                tp=new ThreadPool<T>(); 
            }
            _singletonLock.unlock();
        }
        return tp;
    }
private:
    int _num;//线程个数
    std::vector<Thread*> _threads;//使用vector存放线程
    std::queue<T> _taskQueue;//任务队列，往里面放任务，它是共享资源，需要加锁保护
    pthread_mutex_t _mutex;//互斥锁
    pthread_cond_t _cond;//条件变量

    static ThreadPool<T>* tp;//单例模式静态的对象指针
    static std::mutex _singletonLock;//获取单例对象使用的锁

};
template <class T>
ThreadPool<T>* ThreadPool<T>::tp=nullptr;

template <class T>
std::mutex ThreadPool<T>::_singletonLock;

4.3Task.hpp

#pragma once
#include <iostream>
#include <functional>
#include <string>
void ServerIO(int sock)
{
    char buffer[1024];
    while(1)//适应快速响应的任务，这个任务while其实不太合适
    {
        //服务器读取客户端数据，通过套接字sock这个文件描述符读取数据
        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());
        }
        else if(0==n)//服务器read返回值为0，说明客户端关闭了
        {
            close(sock);
            LogMessage(NORMAL,"client quit,server quit");
            break;
        }
    }
}
class Task
{
    //using func_t=std::function<int(int,int,char)>;
    typedef std::function<void(int)> func_t;//函数对象
public:
    Task()
    {}
    Task(int sock,func_t func)
    :_sock(sock)
    ,_callBack(func)
    {}
    void operator()()//消费者调用
    {
        _callBack(_sock);
    }
private:
    int _sock;
    func_t _callBack;//回调函数
};

5、守护进程+多线程版的TCP客户端、服务器

        其他文件和单进程版一样。

5.1daemon.hpp

#pragma once
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstdlib>
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define DEV "/dev/null"//数据黑洞，向它写入的数据会被吃掉，读取数据什么都读不到（不会使进程退出）
void DaemonSele(const char* currrPath=nullptr)
{
    //1、让调用进程屏蔽异常的信号
    //SIGPIPE信号会在进程向一个已经关闭的socket连接写数据时产生，如果不处理这个信号，进程会被强制退出。通过忽略SIGPIPE信号，可以避免进程因为这个信号而退出。
    signal(SIGPIPE,SIG_IGN);
    //2、让自己不是组长，调用setsid
    if(fork()>0) exit(0);//守护进程也称精灵进程，本质就是一个孤儿进程
    pid_t n=setsid();
    assert(n!=-1);//失败返回-1
    //3、守护进程脱离终端，所以要关闭或重定向进程默认打开的文件及文件描述符
    int fd=open(DEV,O_RDWR);//以读写的方式打开文件黑洞
    if(fd>=0)//创建成功：重定向
    {
        dup2(fd,0);//将fd覆盖标准输入
        dup2(fd,1);
        dup2(fd,2);
        close(fd);
    }
    else//创建失败：手动关闭文件描述符
    {
        close(0);
        close(1);
        close(2);
    }
    //4、进程执行路径更改（可改可不改）
    if(currrPath)
    {
        chdir(currrPath);
    }
}

5.2tcpServer.cc

#include "tcpServer.hpp"
#include "memory"
#include "daemon.hpp"
using namespace Server;
static void Usage(std::string proc)
{
    std::cout<<"Usage:
	"<<proc<<"serverPort

";
}
//./tcpServer local_port
int main(int argc,char* argv[])
{
    if(argc!=2)//判断外部传入的参数是否为2
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port=std::stoi(argv[1]);
    std::unique_ptr<TcpServer> tsvr(new TcpServer(port));
    tsvr->InitServer();
    DaemonSele();//守护进程化，让这个独立的孤儿进程去启动服务器
    tsvr->Start();
    return 0;
}
风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐