linux学习之Socket

编写socket-udp

第一步，编写套接字

第二步，绑定端口号

第三步，启动服务器，读取数据

第四步，接收消息并发回信息给对方

编写socket-Tcp

第一步，编写套接字

第二步，绑定端口号

第三步，将套接字设置为监听状态。

第四步，在服务器运行里获取新连接

第五步，进行读写通信

编写socket-udp

如何认识快速的Udp，我们先来编写一个udp服务器。

第一步，编写套接字

int socket

创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器 )

第一个参数domain即创建套接字的域，如下表：

看以看到有ipv4,ipv6,ipx等。

第二个参数为类型当前socket的类型，如下图所示：

例如sock_stream为有序的可靠的字节流，sock_DGRAM为数据报类型等

第三个为参数protecal,指定域套接字一起使用的特定协议，通常在给定协议族中，只存在一个协议来支持特定的套接字类型。

创建成功会返回一个新的套接字，失败则会返回-1.

第二步，绑定端口号

接口bind

第一个参数为sockfd，套接字id，第二个为套接字类型，这里我们是网络接口，所以应该使用struct sockaddr_in类型的接口。但是我们一般也不会去创建，而是直接定义初始化内存直接用。这里用bzero来初始化内存为0：

之后初始化结构体的内容，设置结构体类型，端口号，ip地址。

之后进行由主机序列转到网络序列：

htons接口：

这些函数名很好记 ,h 表示 host,n 表示 network,l 表示 32 位长整数 ,s 表示 16 位短整数

例如 htonl 表示将 32 位的长整数从主机字节序转换为网络字节序 , 例如将 IP 地址转换后准备发送。

如果主机是小端字节序 , 这些函数将参数做相应的大小端转换然后返回 ;

如果主机是大端字节序 , 这些函数不做转换 , 将参数原封不动地返回。

除了端口号，一般在发送数据时，还需要连ip地址一起打包成封装发送出去，因此对于ip地址我们人需要转化成网络字节序列。分两步转化，现将字符串转化为四字节（uint32_t），再转化为网络字节序列。

当然系统也为我们提供了字符串转为网络字节序的接口 inet_addr:

之后开始绑定，注意结构体（套接字）类型一致，绑定成功返回0，失败返回-1.

第三步，启动服务器，读取数据

recvfrom接口从套接字中获取消息：

参数一位网络文件描述符，参数二为获取的消息，参数三为长度，参数四为标志，当前我们就设置为0，参数五为接收方的套接字，参数六位套接字的大小，后面两个参数是输入型参数。成功返回获取信息的大小。

看可以看到收到消息，我们需要知道消息内容，发消息的源址。

第四步，接收消息并发回信息给对方

收到信息后，发回给对方，调用接口sendto：

参数一为网络文件描述符，参数二为字符缓冲区，参数三为长度，参数四为标志，参数五与参数六接口域recvfrom基本一致，不过这里最后两个参数为输入型参数。

之后我们可以用 netstat -nlup 来查看创建的服务器。

需要注意一点，云服务器不能直接绑定公网ip。我们一般推荐任务地址绑定。

对于端口的选择，我们【0，1023】都是系统端口，直接绑定需要root权限，一般需要有固定的应用协议层使用。绑定我们一般选大一点的端口号。

现在我们就编写一个客户端域服务端的demo版本，先来理解UDP通信：

Udpserver.hpp

#pragma once#include<cstring>
#include<iostream>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
//包含下面两个头文件，此时struct sockeaddr_in 初始化有提示
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
using namespace std;const int Size=1024;
string defaultip="0.0.0.0";
uint16_t defaultport=8080;
enum{SOCKET_ERR=1,Bind_ERR
};class UdpServer
{public:UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false){}//搭建udp网络服务器void Init(){//1.创建套接字  协议为ipv4，类型为数据报 _sockfd=socket(AF_INET,SOCK_DGRAM,0);  //这里除了AF_INIT  也可以写作PF_INITif(_sockfd<0){cout<<"创建套接字失败,socket:"<<socket<<endl;exit(SOCKET_ERR);}else{cout<<"创建套接字成功,socket:"<<socket<<endl;}//2.告诉服务器端口号，绑定端口号struct sockaddr_in local;//内容置空bzero(&local,sizeof(local));//初始化其中内容   local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型local.sin_port=htons(_port);    //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列 //由主机序列转到网络序列提供有接口，我们直接调用转化local.sin_addr.s_addr=inet_addr(_ip.c_str());      //32位的地址,一般用户喜欢用点分十进制的字符串表示，//其次对于ip地址，我们需要将字符串转化为uint32_t //初始化对象完成，开始绑定套接字,设置到内核if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0){printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));exit(Bind_ERR);}cout<<"绑定成功！！！"<<endl;}void Run(){//服务器搭建成功char buffer[Size];is_running=true;   //改变状态while (is_running){//读取数据struct sockaddr_in client;socklen_t len=sizeof(client);ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);if(n<0){printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));continue;}buffer[n]=0; cout<<"接受消息:"<<buffer<<endl;string info=buffer;string string_echo="server echo#"+info;//发回信息给对方sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);}}~UdpServer(){if(_sockfd>0) close(_sockfd);}private:int _sockfd;   //网络文件描述符uint16_t _port;//端口号string _ip; //ip地址 一般绑定任意地址0.0.0.0  可以不需要给出ip。bool is_running;//判断服务器是否再运行
};

对应的.cc

#include"UdpServer.hpp"
#include<memory>void Usage(string p)
{cout<<"\n\rUsage: "<<p<<" prot[1024] bigger "<<endl;
}int main(int argc,char *argv[])
{if(argc!=2){Usage(argv[0]);exit(0);}//构建udp服务器uint16_t port= stoi(argv[1]);const string ip="0.0.0.0";std::unique_ptr <UdpServer> svr(new UdpServer(port,ip));svr->Init();svr->Run();return 0;
}

Udpclient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
using namespace std;
void Usage(string p)
{cout<<"\n Usage:"<<p<<" ip_address   port[1024+]"<<endl;}int main(int argc,char *argv[])
{if(argc!=3){Usage(argv[0]);exit(0);}uint16_t port=stoi(argv[2]);const string ip=argv[1];//构建服务端的套接字struct sockaddr_in server;bzero(&server,sizeof(server));server.sin_addr.s_addr=inet_addr(ip.c_str());server.sin_family=AF_INET;server.sin_port=htons(port);socklen_t len=sizeof(server);int sockfd=socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){cout<<"create socket error"<<endl;return 1;}//需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择//一个端口号只能被一个进程绑定，对于客服端也是如此//客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定string message;char buffer[1024];while(true){cout<<"请输入你要发的消息@";getline(cin,message);//发数据报sendto(sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&server,len);cout<<".............."<<endl;//该客户端可能还会读取其他服务器发消息struct sockaddr_in temp;socklen_t len=sizeof(temp);ssize_t n=recvfrom(sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);if(n>0){buffer[n]=0;cout<<"收到消息："<<buffer<<endl;;}// if(n<0)// {//     printf("收到消息失败,errno %s,错误信息%s\n",errno,strerror(errno));// }else// {//     buffer[n]=0;//     printf("收到消息，消息：%s\n",buffer);// }}close(sockfd);return 0;
}

既然有了服务端那么我们就可以在收到信息时，让他拿到ip地址，端口号和数据报文，同时创建同时在线的用户名单，一个发，所有可以看到。其次客户端显示信息也不太好，我们可以用多线程一个用来收，一个用来发。

改良版：

Udpserver.hpp

class UdpServer
{public:UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false){}//搭建udp网络服务器//udp的套接字是全双工的void Init(){//1.创建套接字  协议为ipv4，类型为数据报 _sockfd=socket(AF_INET,SOCK_DGRAM,0);  //这里除了AF_INIT  也可以写作PF_INITif(_sockfd<0){cout<<"创建套接字失败,socket:"<<socket<<endl;exit(SOCKET_ERR);}else{cout<<"创建套接字成功,socket:"<<socket<<endl;}//2.告诉服务器端口号，绑定端口号struct sockaddr_in local;//内容置空bzero(&local,sizeof(local));//初始化其中内容   local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型local.sin_port=htons(_port);    //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列 //由主机序列转到网络序列提供有接口，我们直接调用转化local.sin_addr.s_addr=inet_addr(_ip.c_str());      //32位的地址,一般用户喜欢用点分十进制的字符串表示，//其次对于ip地址，我们需要将字符串转化为uint32_t //初始化对象完成，开始绑定套接字,设置到内核if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0){printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));exit(Bind_ERR);}cout<<"绑定成功！！！"<<endl;}string Handler(const string info,const string clientip,const uint16_t clientport){cout<<"["<<clientip<<": "<<to_string(clientport)<<"] @"<<info<<endl;string res="server get a message :";res+=("["+clientip+":"+to_string(clientport)+"] @");res+=info;return res;}void Broadcast(const string info,const string clientip,const uint16_t clientport)  //收到消息发送给所有用户{for( auto &it :_users){string messages=" get a message :";messages+=("["+clientip+":"+to_string(clientport)+"] @");messages+=info;socklen_t len=sizeof(it.second);sendto(_sockfd,messages.c_str(),messages.size(),0,(const struct sockaddr*)&(it.second),len);}}bool Checkuser(const struct sockaddr_in user,const string clientip,const uint16_t clientport)//检查用户是否存在，不存在添加用户{auto it=_users.find(clientip);if(it==_users.end()){//添加用户_users.insert(make_pair(clientip,user));cout<<"["<<clientip<<": "<<to_string(clientport)<<"] has added to online_users"<<endl;}}  void Run(){//服务器搭建成功char buffer[Size];is_running=true;   //改变状态while (is_running){//读取数据struct sockaddr_in client;socklen_t len=sizeof(client);ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);if(n<0){printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));continue;}//获取用户的ip地址与端口号uint16_t clientport=ntohs(client.sin_port);std::string clientip=inet_ntoa(client.sin_addr);//先检测用户是否存在过Checkuser(client,clientip,clientport);//广播给所有用户std::string info = buffer;Broadcast(info,clientip,clientport);;//发回信息给对方 string string_echo="echo#"+info;sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);}}~UdpServer(){if(_sockfd>0) close(_sockfd);}private:int _sockfd;   //网络文件描述符uint16_t _port;//端口号string _ip; //ip地址 一般绑定任意地址0.0.0.0  可以不需要给出ip。bool is_running;//判断服务器是否再运行//保存客户端用户信息std::unordered_map<string,struct sockaddr_in> _users;
};

ucpclient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<pthread.h>
using namespace std;struct ThreadDate
{int sockfd;struct sockaddr_in server;};
void Usage(string p)
{cout<<"\n Usage:"<<p<<" ip_address   port[1024+]"<<endl;}void *send_message(void *args)
{ThreadDate *td=static_cast<ThreadDate*>(args);std::string message;socklen_t len=sizeof(td->server);while(true){cout<<"请输入你要发的消息@";getline(cin,message);//发数据报sendto(td->sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&(td->server),len);cout<<".............."<<endl;}}
void *recive_mesage(void *args)
{ThreadDate *td=static_cast<ThreadDate*>(args);char buffer[1024];while(true){struct sockaddr_in temp;socklen_t len=sizeof(temp);ssize_t n=recvfrom(td->sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);if(n>0){buffer[n]=0;cout<<"收到消息："<<buffer<<endl;;}}
}
int main(int argc,char *argv[])
{if(argc!=3){Usage(argv[0]);exit(0);}uint16_t port=stoi(argv[2]);const string ip=argv[1];struct ThreadDate td;//初始化服务端的套接字bzero(&td.server,sizeof(td.server));td.server.sin_addr.s_addr=inet_addr(ip.c_str());td.server.sin_family=AF_INET;td.server.sin_port=htons(port);socklen_t len=sizeof(td.server);td.sockfd=socket(AF_INET,SOCK_DGRAM,0);if(td.sockfd<0){cout<<"create socket error"<<endl;return 1;}//需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择//一个端口号只能被一个进程绑定，对于客服端也是如此//客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定//创建两个线程  一个用来接受，一个用来发送pthread_t reciver,sender;pthread_create(&reciver,nullptr,recive_mesage,&td);pthread_create(&sender,nullptr,send_message,&td);    pthread_join(reciver,nullptr);pthread_join(sender,nullptr);

这里在编写的时候注意地址转化函数，,sockaddr_in中的成员struct in_addr sin_addr表示32位的IP 地址但是我们通常用点分十进制的字符串表示IP 地址,以下函数可以在字符串表示和in_addr表示之间转换;

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void*addrptr。

关于inet_ntoa：inet_ntoa这个函数返回了一个char*, 很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果. 那么是否需要调用者手动释放呢?

实际上内部放在了静态区中，但是多线程在竞争调用时，还是会出现线程安全，现在在centos7上好像做了改善，里面加了锁，但是应用的时候，如果我们不放心还是尽量使用inet_mtop这样的接口。

编写socket-Tcp

学了Udp套接字的编写，Tcp相对来说会好一点，因为Tcp与Udp本来就是有交集的。

首先刚开始的套路一样：

第一步，编写套接字

与udp一样，创建sockfd文件描述符。不过这里的参数二即类型我们设置为 SOCK_STREAM（数据流）类型。

第二步，绑定端口号

在绑定端口号前，需要创建sock_addrin结构体并初始化，在将字符串Ip地址转化为网络字节序，我们这里使用的接口为inet_aton().

参数一为char*类型ip，参数二为sin_addr.

第三步不一样。

第三步，将套接字设置为监听状态。

listen 将套接字设置为监听状态

成功返回0，错误返回-1.第二个参数代表列表长度。

第四步，在服务器运行里获取新连接

accept获取新连接

参数一文件描述符，后两个参数为输出型参数，为addrin及其长度，可以获知哪一个客户端的信息。返回值成功返回文件描述符，否则返回-1。

与Udp不同，udp的套接字从始至终都只有一个，而Tcp有两个，实际上最开始的套接字，并不是我们要去通信的套接字，Tcp通信的套接字，是要在accept之后的套接字。因此之前的套接字，我们也可以叫做监听套接字。

之后我们就可以测试了，即使我们没写客户端，但在系统下会有一个工具telnet,可以指定登录远程服务器。

这里注意一点，无论是Tcp还是Udp我们都无法绑定公网ip。

第五步，进行读写通信

与Udp不同，我们这里不使用recvfrom与sendto接收发送消息，而是用文件描述符进行通信。

用read与write。

之后就可以编写客户端进行通信了。

对于客户端通过connect发起连接。

后两个参数为输出型参数，用来保存信息。成功返回0，否则-1.

Tcpserver.hpp

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <memory>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
using namespace std;
// 错误码
enum
{SOCKERROR = 2,BINDERROR,LISTENERROR,ACCEPTEEROR
};
const uint16_t defaultfd = -1;
const std::string defaultip = "127.0.0.1";
const uint16_t defaultport = 8080;
class TcpServer;
struct PthreadData
{PthreadData( int sockfd,std::string clientip,uint16_t port,TcpServer*tcp):_newsockfd(sockfd),_clientip(clientip),_clientport(port),_server(tcp){}int _newsockfd;std::string _clientip;uint16_t _clientport;TcpServer *_server;
};
class TcpServer
{
public:TcpServer(const uint16_t port = defaultport, const int socket = defaultfd, const string ip = defaultip) : _port(port), _listensockfd(socket), _ip(ip){}void Init(){// 创建套接字_listensockfd = socket(AF_INET, SOCK_STREAM, 0); // TCP我们使用流类型if (_listensockfd == -1){cout << "错误码：" << errno << ",错误信息: " << strerror(errno) << endl;exit(SOCKERROR);}cout << "创建成功......" << endl;// 创建sockaddr 并且绑定端口号struct sockaddr_in local;bzero(&local, sizeof(local));local.sin_family = AF_INET;// local.sin_addr.s_addr=inet_addr(c_str(_ip));local.sin_port = htons(_port);inet_aton(_ip.c_str(), &(local.sin_addr));socklen_t len = sizeof(local);// 绑定套接字int n = bind(_listensockfd, (const struct sockaddr *)&local, len);if (n < 0){cout << "绑定失败,错误码:" << errno << "，错误信息:" << strerror(errno) << endl;exit(BINDERROR);}cout << "绑定成功........." << endl;// 将套接字设置为监听状态// 因为Tcp是面向字节流的，且是被动的，服务器需要一直打开来接受客户端的请求if (listen(_listensockfd, 5) == -1){cout << "设置监听失败"<< "错误码，" << errno << "错误信息" << strerror(errno) << endl;exit(LISTENERROR);}cout << "listen has finished......" << endl;}void Service(int &sockfd, uint16_t &port, char *ip){// 测试收到消息显示出来,char buffer[1024];// 读取消息while (true){ssize_t n = read(sockfd, buffer, sizeof(buffer));fflush(stdin);if (n > 0){buffer[n] = 0;cout << "收到来自 ip:" << ip << "端口号：" << port << "的消息:" << buffer << endl;// 写回消息，发送消息string inputbuffer = "server recive message";inputbuffer += buffer;write(sockfd, inputbuffer.c_str(), inputbuffer.size());}else{cerr << "信息读取错误，错误码" << errno << "，错误信息" << strerror(errno) << endl;break;}}}static void *Running(void *args){PthreadData*data=static_cast<PthreadData*> (args);pthread_detach(pthread_self());data->_server->Service(data->_newsockfd, data->_clientport, (char*)(data->_clientip).c_str());//这里不能关闭描述符delete data;return nullptr;}void Start(){while (true){cout << "server is running....." << endl;sleep(1);// 由于参数为输出型参数，需要给一个sockaddrin来保存客户端的信息struct sockaddr_in client;socklen_t len = sizeof(client);// 获取新连接int newsockfd = accept(_listensockfd, (struct sockaddr *)&client, &len); // 阻塞式等待// 对于这两个套接字  ，—listensockfd，可以理解为拉拢客户端 newsockfd，理解为处理客户端// 之前的监听套接字不是我们真正要去处理客户端的套接字 ，只有在accept之后获取的新套接字才是if (newsockfd < 0) // 客户端会有很多，accept失败继续去accept{cout << "accept error" << endl;continue;}uint16_t clientport = htons(client.sin_port);char clientip[80];// 转为char*inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));// 根据新连接通信cout << "get a new link.....,"<< "端口号: " << clientport << "ip :" << clientip << endl;// 通过newsockfd进行通信// 提供服务// Service(newsockfd, clientport, clientip);// close(newsockfd);// 修改为多进程版// pid_t id = fork();// if (id == 0)// {//     close(_listensockfd);//     // 子进程//     if(fork()>0)//     {//         //当前进程直接退出//         exit(0);//     }//     //孙子进程来执行service//     //我直接退出，孙子进程交给系统领养就可以并发访问了。//     Service(newsockfd, clientport, clientip);//     close(newsockfd);//     exit(0);// }// close(newsockfd);//这里注意需要关闭 子进程已经拿去用了，如果不关，父进程的文件描述符越来越少// //这里其实也并不会关闭，里面有引用计数// // 父进程// pid_t rid = waitpid(id, nullptr,0);//子进程是阻塞等待，但父进程我们要求继续运行，这里等待设置为// (void)rid;//但是创建进程消耗太大，还是不是很好，因此我们用线程来执行pthread_t tid;PthreadData *data=new PthreadData(newsockfd,clientip,clientport,this);pthread_create(&tid, nullptr,Running,data);//我们不想让它直接等待，而是自己去玩自己的，设置detach}}private:int _listensockfd;uint16_t _port;string _ip;
};

main.cc

#include<iostream>
#include<memory>
#include <unistd.h>
#include"Tcpserver.hpp"void Helper(char *str)
{cout<<"please enter command in correct :"<<str<<" port[1024+]."<<endl;
}
int main(int argc,char*argv[])
{if(argc!=2){Helper(argv[0]);exit(1);}uint16_t port=atoi(argv[1]);std::unique_ptr <TcpServer> svr(new TcpServer(port));svr->Init();svr->Start();
}

Tcpclient.cc

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
using namespace std;void Helper(char *s)
{cout<<"please enter in coorrct command"<<s<<" port[1024+],"<<" ip(0.0.0.0)"<<endl;
}
int main(int argc,char *argv[])
{if(argc!=3){Helper(argv[0]);exit(1);}uint16_t serverport=stoi(argv[1]);string serverip=string(argv[2]);int sockfd=socket(AF_INET,SOCK_STREAM,0);if(sockfd<0){cerr<<"Error,创建套接字错误"<<endl;return 1;}//不需要显示绑定，系统给绑定了,会在我们connect发起连接后，自动随机绑定//发起连接//通过命令行参数获取ip地址与端口号struct sockaddr_in server;bzero(&server, sizeof(server));server.sin_family=AF_INET;inet_pton(AF_INET,serverip.c_str(),&server.sin_addr);server.sin_port=htons(serverport);socklen_t len=sizeof(server);int n=connect(sockfd,(const struct sockaddr*)&server,len);if(n<0){cerr<<"Error,连接失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;return 2;}cout<<"连接成功......"<<endl;//发消息while(true){string message;cout<<"please enter#"<<endl;getline(cin,message);//将消息写入文件中write(sockfd,message.c_str(),message.size());//写完消息，再接受来自服务端的消息char buf[1024];int n=read(sockfd,buf,sizeof(buf));if(n<0){cerr<<"接收消息失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;}else{buf[n]=0;cout<<"port :"<<serverport<<" ip:"<<serverip<<"recive:"<<buf<<endl;}}close(sockfd);return 0;}

这里的多线程也不是最好的，因为可能存在多线程，少资源的情况，这里最后直接把线程池拿过来，我需要几个线程就创造几个线程来用。从而效果达到更优。