Linux---网络套接字
端口号
端口号
端口号是一个2字节16位的整数;
端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;
IP地址 + 端口号能够标识网络上的某一台主机的某一个进程;
一个端口号只能被一个进程占用
在公网上，IP地址能表示唯一的一台主机，端口号port，用来表示该主机上的唯一的一个进程，IP:port = 标识全网唯一的一个进程。
现在用户要刷抖音，假如抖音的端口号为4321，获取一个抖音短视频，抖音应用通过协议连接到抖音服务器的IP地址，然后建立连接，抖音服务器传送短视频的数据到达用户的设备上。在通信的过程中，一定要知道端口号，不知道的话无法通信。
一个进程可以绑定多个端口号，但是一个端口号不能被多个进程绑定。
认识TCP协议
此处我们先对TCP(Transmission Control Protocol 传输控制协议)有一个直观的认识; 后面我们再详细讨论TCP的一些细节问题.
传输层协议
有连接
可靠传输
面向字节流
认识UDP协议
此处我们也是对UDP(User Datagram Protocol 用户数据报协议)有一个直观的认识; 后面再详细讨论.
传输层协议
无连接
不可靠传输
面向数据报
网络字节序
我们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分, 磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分, 网络数据流同样有大端小端之分. 那么如何定义网络数据流的地址呢 ？
大端：低位地址存放高位数据，高位地址存放低位数据
小端：低位地址存放低位数据，高位地址存放高位数据
大端和小端只是对数据类型长度是两个及以上的，如int short,对于单字节没限制，在网络中经常需要考虑大端和小端的是ip和端口。
发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出;
接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存;
因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址.
TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节.
不管这台主机是大端机还是小端机, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据;
如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可;
在网络通信中，为了确保数据在不同系统之间能正确解释，网络字节序被定义为大端序。
为使网络程序具有可移植性,使同样的C代码在大端和小端计算机上编译后都能正常运行,可以调用以下库函数做网络字节序和主机字节序的转换。
这些函数名很好记,h表示host,n表示network,l表示32位长整数,s表示16位短整数。
例如htonl表示将32位的长整数从主机字节序转换为网络字节序,例如将IP地址转换后准备发送。
如果主机是小端字节序,这些函数将参数做相应的大小端转换然后返回 ;
如果主机是大端字节序,这些 函数不做转换,将参数原封不动地返回。
IP地址转换函数
inet_pton 函数是一个用于将点分十进制的IPv4或IPv6地址转换为二进制形式的函数，
即将地址从文本表示形式转换为网络字节序的二进制形式。这个函数的声明如下：
#include
int inet_pton(int af, const char *src, void *dst);
af 参数表示地址族，可以是 AF_INET 表示IPv4，也可以是 AF_INET6 表示IPv6。
src 参数是包含要转换的IP地址的点分十进制字符串。
dst 参数是指向存储转换后二进制形式的地址的指针。
函数的返回值是整数，如果转换成功，则返回1（表示成功），
如果地址格式无效或发生错误，则返回nullptr（表示无效的地址格式）
或-1（表示发生了错误）。 - IP 地址转换函数:
- p->表示点分十进制的字符串形式
- to->到
- n->表示 network 网络
地址转换函数
inet_ntop 函数是用于将网络字节序的地址转换为字符串表示的函数。
它是IPv4和IPv6通用的函数，可以用于将网络地址转换为点分十进制字符串或IPv6的十六进制字符串。
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
af：地址族（Address Family），通常是 AF_INET 表示IPv4，AF_INET6 表示IPv6。
src：指向存储网络地址的结构体的指针。
dst：用于存储转换后的字符串的缓冲区指针。
size：缓冲区的大小。
该函数成功时返回指向转换后的字符串的指针，失败时返回 NULL。还有另一个函数
#include
in_addr_t inet_addr(const char *cp);
这个函数接受一个表示IP地址的字符串（cp参数），
并返回一个in_addr_t类型的二进制格式表示的IP地址。
如果转换失败，函数返回INADDR_NONE。
这个函数仅支持IPV4 socket编程常见接口
// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器
int socket(int domain, int type, int protocol)
函数描述：创建socket
参数说明：
domain:协议版本
AF_INET IPV4
AF_INET6 IPV6
AF_UNIX_LOACL 本地套接字使用
type:协议类型
SOCK_STREAM 流式，默认使用的协议是tcp协议
SOCK_DGRAM报式，默认使用的是udp协议
protocal:
一般填0,表示使用对应类型的默认协议// 绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr *address,
socklen_t address_len);
函数描述：将socket文件描述符和ip,port绑定
参数说明:
socket: 调用 socket 孟数返回的文件描述符
addr: 本地服务器的 IP 地址和 PORT,
struct sockaddr_in serv;
serv.sin_family = AF_INET:
serv.sin_port = htons(8888):
//serv.sin_addr.s_addr = htonl(INADDR_ANY):
//INADDR_ANY: 表示使用本机任意有效的可用IP
inet_pton(AF_INET, "127.0.0.1", &serv.sin_addr.s_addr)
addrlen: addr 变量的占用的内存大小
返回值:失败返回-1，并设置errno// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog)
函数描述: 将套接字由主动态变为被动态
参数说明:
socket: 调用 socket 函数返回的文件描述符
backlog: 同时请求连接的最大个数(还未建立连接)
返回值:
成功: 返回0
失败: 返回-1，并设置errno// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,
socklen_t* address_len);
accept 函数是一个阻寒函数，若没有新的连接请求，则一直阻寒.
从已连接队列中获取一个新的连接，并获得一个新的文件描述符，该文件描
述符用于和客户端通信. (内核会负责将请求队列中的连接拿到已连接队列中)
函数参数：
sockfd:调用 socket 函数返回的文件描述符
addr:传出参数，保存客户端的地址信息
addrlen: n:传入传出参数，addr变量所占内存空间大小
返回值：
成功：返回一个新的文件描述符，用于和客户端通信
失败：返回-1,并设置errno值，// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,
socklen_t addrlen);
函数说明: 连接服务器
函教参款:
sockfd: 调用 socket 函数返回的文件描述符
addr: 服务端的地址信息
addrlen: addr 变量的内存大小
返回值:
成功: 返回0
失败: 返回-1，并设置errno 值socket变成用到的重要的结构体 struct sockaddr
sockaddr结构
sockaddr_in结构
虽然socket api的接口是sockaddr, 但是我们真正在基于IPv4编程时, 使用的数据结构是sockaddr_in; 这个结构里主要有三部分信息: 地址类型, 端口号, IP地址.
in_addr结构
in_addr用来表示一个IPv4的IP地址. 其实就是一个32位的整数 。
UDP通信
在网络通信中，一般不使用read和write这两个接口的。
当有人来发送消息的时候，你想知道是谁发的消息。
可以使用recvfrom函数，这个函数中存在一个src_addr参数，这个结构体需要我们自己定义，然后将结构体对象传入进去，就可以知道是谁发送的信息了。
发送数据可以使用sendto。
在这里，简单的写了一个日志系统，后面就不再使用perror，而是直接使用日志系统来提示错误。
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#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 logmessage(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\n", leftbuffer, rightbuffer);
// // printf("%s", logtxt); // 暂时打印
// printLog(level, logtxt);
// }
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\n", leftbuffer, rightbuffer);
// printf("%s", logtxt); // 暂时打印
printLog(level, logtxt);
}
private:
int printMethod;
std::string path;
};
// int sum(int n, ...)
// {
// va_list s; // char*
// va_start(s, n);
// int sum = 0;
// while(n)
// {
// sum += va_arg(s, int); // printf("hello %d, hello %s, hello %c, hello %d,", 1, "hello", 'c', 123);
// n--;
// }
// va_end(s); //s = NULL
// return sum;
// } #pragma once
#include
#include
#include
#include
#include
#include "log1.hpp"
std::string defaultip = "0.0.0.0";
Log log;
#define SIZE 1024
class UdpServer
{
public:
UdpServer(uint16_t port, std::string ip = defaultip)
:_port(port)
,_ip(ip)
{}
void Init()
{
// 1.创建socket文件描述符，IPV4，UDP，使用对应类型的默认协议
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
log(Fatal, "socket fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(Info, "sockfd successful");
// 2.绑定端口号
struct sockaddr_in serv;
bzero(&serv, sizeof(serv)); // 初始化addr
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
int bd = bind(sockfd, (const struct sockaddr*)&serv, sizeof(serv));
if (bd < 0)
{
log(Fatal, "bind fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(bd, "bind successful");
}
void Run()
{
IsConnect = true;
char inbuf[SIZE];
while (IsConnect)
{
struct sockaddr_in client;
bzero(&client, sizeof(client));
socklen_t len = sizeof(client);
ssize_t n = recvfrom(sockfd, inbuf, sizeof(inbuf) - 1, 0,(struct sockaddr*)&client, (socklen_t *)&len);
if (n < 0)
{
log(Fatal, "recvfrom fail, error string: %s, error code: %d", strerror(errno), errno);
continue;
}
inbuf[n] = 0;
std::string info = inbuf;
std::string echo_string = "server echo# " + info;
sendto(sockfd, echo_string.c_str(), echo_string.size(), 0, (struct sockaddr*)&client, len);
}
}
~UdpServer()
{}
public:
uint16_t _port;
std::string _ip;
bool IsConnect;
int sockfd;
}; #include "UdpServer.hpp"
#include
int main()
{
std::unique_ptr udp(new UdpServer(8080));
udp->Init();
udp->Run();
return 0;
} 
通过 netstat -naup可以查看运行的udp的情况。
只要能用上面的指令查到，就说明我们的服务已经启动了。
当我们把IP改成云服务器的ip，会出现这样的情况，首先端口号是没问题的。
如果你用的是虚拟机，代码是可以运行的。但我今天用的是云服务器，是禁止直接bind公网IP的。当我们服务器有多张网卡的时候，这个IP地址可能就不是唯一的，其他IP地址也可以连接我们这个服务器，所以一般在绑定IP的时候，可以设为0，bind(IP:0)， 凡是发给我这台主机的数据，我们都要根据端口号向上交付。
绑定IP地址为0----任意地址bind。
现在将端口号改为80.
会出现这样的错误。
在进行提权之后，就能绑定这个端口号了。
一般情况下，[1,1023]是系统内定的端口号，一般都有固定的应用层协议使用，http:80， https：443， mysql：3306，这种端口号一般就别在使用了。可以考虑8000以上的。
修改一下UdpServer，使用命令行，以./main port的方式执行程序。
#include "UdpServer.hpp"
#include
int main(int argc, char *argv[])
{
if (argc != 2)
{
std::cout << "fail!" << std::endl;
return 1;
}
uint16_t port = std::atoi(argv[1]);
std::unique_ptr udp(new UdpServer(port));
udp->Init();
udp->Run();
return 0;
} 
现在简单实现一个客户端，来完成通信。
客户端需要bind吗？服务端的bind部分写了一大堆，客户端也需要绑定，服务器要找到客户端，所以也需要bind，只不过不需要用户显示的bind。bind的过程一般会有OS自由随机选择。
一个端口号只能被一个进程bind，对server是如此，对client也是如此。其实client的port是多少，其实不重要，只要能保证主机上的唯一性就可以。系统什么时候bind呢？首次发送数据的时候。
#include
#include
#include
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
if (argc != 3)
{
cout << "fail" << endl;
return 1;
}
std::string serverip = argv[1];
uint16_t serverport = std::stoi(argv[2]);
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(serverport);
inet_pton(AF_INET, serverip.c_str(), &serv.sin_addr.s_addr);
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
cout << "socket fail" << endl;
return 1;
}
string msg;
char buffer[1024];
while (true)
{
cout << "Please Enter@ ";
getline(cin, msg);
sendto(sockfd, msg.c_str(), msg.size(), 0, (const sockaddr*)&serv, sizeof(serv));
struct sockaddr_in temp;
socklen_t len = sizeof(temp);
ssize_t s = recvfrom (sockfd, buffer, 1023, 0, (struct sockaddr*)&serv, &len);
if (s > 0)
{
buffer[s] = 0;
cout << buffer << endl;
}
}
close(sockfd);
return 0;
} 这就是一个简单的客户端，在运行服务端和客户端的时候，就能完成两者之间的通信了。
#pragma once
#include
#include
#include
#include
#include
#include "log1.hpp"
std::string defaultip = "0.0.0.0";
Log log;
#define SIZE 1024
class UdpServer
{
public:
UdpServer(uint16_t port, std::string ip = defaultip)
:_port(port)
,_ip(ip)
{}
void Init()
{
// 1.创建socket文件描述符，IPV4，UDP，使用对应类型的默认协议
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
log(Fatal, "socket fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(Info, "sockfd successful");
// 2.绑定端口号
struct sockaddr_in serv;
bzero(&serv, sizeof(serv)); // 初始化addr
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
int bd = bind(sockfd, (const struct sockaddr*)&serv, sizeof(serv));
if (bd < 0)
{
log(Fatal, "bind fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(Info, "bind successful");
}
void Run()
{
IsConnect = true;
char inbuf[SIZE];
while (IsConnect)
{
struct sockaddr_in client;
bzero(&client, sizeof(client));
socklen_t len = sizeof(client);
ssize_t n = recvfrom(sockfd, inbuf, sizeof(inbuf) - 1, 0,(struct sockaddr*)&client, &len);
if (n < 0)
{
log(Fatal, "recvfrom fail, error string: %s, error code: %d", strerror(errno), errno);
continue;
}
inbuf[n] = 0;
std::string info = inbuf;
std::string echo_string = "server echo# " + info;
std::cout << echo_string << std::endl;
sendto(sockfd, echo_string.c_str(), echo_string.size(), 0, (struct sockaddr*)&client, len);
}
}
~UdpServer()
{
close(sockfd);
}
public:
uint16_t _port;
std::string _ip;
bool IsConnect;
int sockfd;
}; #include "UdpServer.hpp"
#include
int main(int argc, char *argv[])
{
if (argc != 2)
{
std::cout << "fail!" << std::endl;
return 1;
}
uint16_t port = std::atoi(argv[1]);
std::unique_ptr udp(new UdpServer(port));
udp->Init();
udp->Run();
return 0;
} 服务端和客户端可以直接
以这样的方式运行，
./UdpClient ip port。
通过这个选项可以将远程服务器中的文件发送到本地。
通过rz可以将本地文件发送到远程服务器。现在我使用两个不同的服务器，来运行客户端。上传之后是没有x权限的，使用chmod +x 文件名 可以获得x权限。
然后运行程序，是可以通信的。
所以网络通信最终就是这样子的，只不过可以在进行适当的结耦。
当然udp不仅仅可以只进行通信，如果客户端发送的是指令，我们接收到这个指令的时候可以去处理这个指令。
通过popen函数。
用于创建一个由调用进程执行命令并建立到该命令的标准输入或标准输出的管道。
FILE *popen(const char *command, const char *mode);- command 参数是一个字符串，表示要执行的命令。这个字符串会被传递给 shell 进行解释。
- mode 参数是一个字符串，表示使用的管道的模式。 "r"（只读模式）和 "w"（只写模式）。
popen 返回一个指向 FILE 结构的指针，该结构描述了与新进程的连接。可以使用返回的文件指针进行读取或写入，就像处理常规文件一样。
std::string Command(const std::string &cmd)
{
FILE* fp = popen(cmd.c_str(), "r");
if (fp == nullptr)
{
perror("popen");
return "error";
}
std::string ret;
char buf[2048];
while (true)
{
char *tail = fgets(buf, sizeof(buf), fp);
if (tail == nullptr)
{
break;
}
ret += buf;
}
return ret;
}当然， 在处理客户端的指令之前，要进行检查，避免出现客户端执行rm -rf等之类的指令。
上述通信的源代码
// UdpServer.hpp
#pragma once
#include
#include
#include
#include
#include
#include
#include "log1.hpp"
// 在Run中带一个参数，这个参数是客户端需要做的事情。可以用function进行封装。然后通过传入的参数来改变客户端需要做的事情。
using func_t = std::function;
std::string defaultip = "0.0.0.0";
Log log;
#define SIZE 1024
class UdpServer
{
public:
UdpServer(uint16_t port, std::string ip = defaultip)
:_port(port)
,_ip(ip)
{}
void Init()
{
// 1.创建socket文件描述符，IPV4，UDP，使用对应类型的默认协议
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
log(Fatal, "socket fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(Info, "sockfd successful");
// 2.绑定端口号
struct sockaddr_in serv;
bzero(&serv, sizeof(serv)); // 初始化addr
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
int bd = bind(sockfd, (const struct sockaddr*)&serv, sizeof(serv));
if (bd < 0)
{
log(Fatal, "bind fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(Info, "bind successful");
}
void Run(func_t func)
{
IsConnect = true;
char inbuf[SIZE];
while (IsConnect)
{
struct sockaddr_in client;
bzero(&client, sizeof(client));
socklen_t len = sizeof(client);
ssize_t n = recvfrom(sockfd, inbuf, sizeof(inbuf) - 1, 0,(struct sockaddr*)&client, &len);
if (n < 0)
{
log(Fatal, "recvfrom fail, error string: %s, error code: %d", strerror(errno), errno);
continue;
}
inbuf[n] = 0;
std::string info = inbuf;
std::string echo_string = func(info);
sendto(sockfd, echo_string.c_str(), echo_string.size(), 0, (struct sockaddr*)&client, len);
}
}
~UdpServer()
{
close(sockfd);
}
public:
uint16_t _port;
std::string _ip;
bool IsConnect;
int sockfd;
}; // Main.cc
#include "UdpServer.hpp"
#include
#include
std::string Handler(const std::string &msg)
{
std::string res = "Server get a message : ";
res += msg;
std::cout << res << std::endl;
return res;
}
std::string Command(const std::string &cmd)
{
FILE* fp = popen(cmd.c_str(), "r");
if (fp == nullptr)
{
perror("popen");
return "error";
}
std::string ret;
char buf[2048];
while (true)
{
char *tail = fgets(buf, sizeof(buf), fp);
if (tail == nullptr)
{
break;
}
ret += buf;
}
return ret;
}
int main(int argc, char *argv[])
{
if (argc != 2)
{
std::cout << "fail!" << std::endl;
return 1;
}
uint16_t port = std::atoi(argv[1]);
std::unique_ptr udp(new UdpServer(port));
udp->Init();
udp->Run(Command);
return 0;
} // UdpClient.cc
#include
#include
#include
#include
#include
#include
using namespace std;
int main(int argc, char *argv[])
{
if (argc != 3)
{
cout << "fail" << endl;
return 1;
}
std::string serverip = argv[1];
uint16_t serverport = std::stoi(argv[2]);
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(serverport);
inet_pton(AF_INET, serverip.c_str(), &serv.sin_addr.s_addr);
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
cout << "socket fail" << endl;
return 1;
}
string msg;
char buffer[1024];
while (true)
{
cout << "Please Enter@ ";
getline(cin, msg);
sendto(sockfd, msg.c_str(), msg.size(), 0, (const sockaddr*)&serv, sizeof(serv));
struct sockaddr_in temp;
socklen_t len = sizeof(temp);
ssize_t s = recvfrom (sockfd, buffer, 1023, 0, (struct sockaddr*)&serv, &len);
if (s > 0)
{
buffer[s] = 0;
cout << buffer << endl;
}
}
close(sockfd);
return 0;
} .PHONY:all
all:UdpServer UdpClient
UdpServer:Main.cc
g++ -o $@ $^ -std=c++11 -lpthread
UdpClient:UdpClient.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm UdpClient UdpServer使用Udp做一个聊天
简单的对UdpServer.hpp中的代码进行了一个更改。
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include "log1.hpp"
// 在Run中带一个参数，这个参数是客户端需要做的事情。可以用function进行封装。然后通过传入的参数来改变客户端需要做的事情。
using func_t = std::function;
std::string defaultip = "0.0.0.0";
Log log;
#define SIZE 1024
class UdpServer
{
public:
UdpServer(uint16_t port, std::string ip = defaultip)
:_port(port)
,_ip(ip)
{}
void Init()
{
// 1.创建socket文件描述符，IPV4，UDP，使用对应类型的默认协议
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
log(Fatal, "socket fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(Info, "sockfd successful");
// 2.绑定端口号
struct sockaddr_in serv;
bzero(&serv, sizeof(serv)); // 初始化addr
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
int bd = bind(sockfd, (const struct sockaddr*)&serv, sizeof(serv));
if (bd < 0)
{
log(Fatal, "bind fail, error string: %s, error code: %d", strerror(errno), errno);
exit(-1);
}
log(Info, "bind successful");
}
void CheckOnlineUser(const struct sockaddr_in &client,std::string& ip, uint16_t& port)
{
auto iter = online_user.find(ip);
if (iter == online_user.end())
{
online_user.insert({ip, client});
std::cout << "[" + ip + ":" + std::to_string(port) + "]#" << "add new client" << std::endl;
}
}
std::string func(std::string info, std::string ip, uint16_t port)
{
std::string echo_string = "[" + ip + ":" + std::to_string(port) + "]#" + info;
return echo_string;
}
void BroadCast(std::string &info, std::string &ip, uint16_t &port)
{
for (auto &it : online_user)
{
sendto(sockfd, info.c_str(), info.size(), 0, (const struct sockaddr*)&it.second, sizeof(it.second));
}
}
void Run()
{
IsConnect = true;
char inbuf[SIZE];
while (IsConnect)
{
struct sockaddr_in client;
bzero(&client, sizeof(client));
socklen_t len = sizeof(client);
ssize_t n = recvfrom(sockfd, inbuf, sizeof(inbuf) - 1, 0,(struct sockaddr*)&client, &len);
if (n < 0)
{
log(Fatal, "recvfrom fail, error string: %s, error code: %d", strerror(errno), errno);
continue;
}
inbuf[n] = 0;
std::string client_ip = inet_ntoa(client.sin_addr);// 获取用户的ip
uint16_t client_port = ntohs(client.sin_port);// 获取用户的端口号
CheckOnlineUser(client,client_ip, client_port);// 检查在线的用户，若有新上线的，会进行提醒
std::string info = inbuf;
// std::string echo_string = func(info);
std::string echo_string = func(info, client_ip, client_port);// 将信息拼接为字符串
BroadCast(echo_string,client_ip, client_port);// 将这条信息转发给所有人
// sendto(sockfd, echo_string.c_str(), echo_string.size(), 0, (struct sockaddr*)&client, len);
}
}
~UdpServer()
{
close(sockfd);
}
public:
uint16_t _port;
std::string _ip;
bool IsConnect;
int sockfd;
std::unordered_map online_user;// 用来存储所有客户端的IP和sockaddr
};
inet_ntoa 是一个用于将 IPv4 地址从二进制表示转换为点分十进制字符串表示的函数。它通常在网络编程中使用，特别是在处理套接字编程时。
因为客户端是单线程的原因，每次循环收到一条信息后，在getline中会被阻塞，这就导致服务端转发消息的时候，不能及时的将所有的信息转发出来。
下面将客户端改为多线程。
#include
#include
#include
#include
#include
#include
#include
#include
using namespace std;
pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
struct ThreadData
{
struct sockaddr_in serv;
int sockfd;
};
void *recv_msg(void *args)
{
// OpenTerminal();
ThreadData *td = static_cast(args);
char buffer[1024];
while (true)
{
memset(buffer, 0, sizeof(buffer));
struct sockaddr_in temp;
socklen_t len = sizeof(temp);
ssize_t s = recvfrom(td->sockfd, buffer, 1023, 0, (struct sockaddr *)&temp, &len);
if (s > 0)
{
buffer[s] = 0;
cerr << buffer << endl;
}
}
}
void *send_msg(void *args)
{
ThreadData *td = static_cast(args);
string message;
socklen_t len = sizeof(td->serv);
sendto(td->sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&(td->serv), len);
while (true)
{
cout << "Please Enter@ ";
getline(cin, message);
sendto(td->sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&(td->serv), len);
}
}
int main(int argc, char *argv[])
{
if (argc != 3)
{
cout << "fail" << endl;
return 1;
}
struct ThreadData td;
std::string serverip = argv[1];
uint16_t serverport = std::stoi(argv[2]);
bzero(&td.serv, sizeof(td.serv));
td.serv.sin_family = AF_INET;
td.serv.sin_port = htons(serverport);
inet_pton(AF_INET, serverip.c_str(), &td.serv.sin_addr.s_addr);
td.sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (td.sockfd < 0)
{
cout << "socket fail" << endl;
return 1;
}
pthread_t client_send, client_recv;
pthread_create(&client_send, nullptr, send_msg, &td);
pthread_create(&client_recv, nullptr, recv_msg, &td);
pthread_join(client_send, nullptr);
pthread_join(client_recv, nullptr);
close(td.sockfd);
return 0;
} 这样就可以实时的将所有用户发送的信息转发到屏幕上了，类似于群聊。
TcpServer
TCP协议跟 UDP协议有点不同。
在街上，会碰到一些饭店门口站的有专门拉客的人，如果有客人要去他们饭店吃饭，他会把你领到饭店里面，然后进去之后让其他人接待你，然后拉客的人继续去外面拉客。而TCP中的listen就是拉客的人。它负责监听每一个要连接服务端的人。而accept就是服务员，你要向客户端发送什么信息都是通过accept返回的文件描述符来进行通信的。
#pragma once
#include
#include
#include
#include
#include
#include "log1.hpp"
Log lg;
const std::string defaultip = "0.0.0.0";
const int backlog = 5;
class TcpServer
{
public:
TcpServer(uint16_t port, const std::string ip = defaultip, int lsfd = -1)
:_port(port)
,_ip(ip)
,_listensockfd(lsfd)
{}
void Init()
{
_listensockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建监听socket的文件描述符
if (_listensockfd < 0)
{
lg(Fatal, "socket fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "socket successful");
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
if (bind(_listensockfd, (const struct sockaddr*)&serv, sizeof(serv)) < 0) // 注册
{
lg(Fatal, "bind fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "bind successful");
if (listen(_listensockfd, backlog) < 0) // 监听
{
lg(Fatal, "listen fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "listen successful");
}
void Service()
{
char buf[4096];
while (true)
{
ssize_t n = read(_sockfd, buf, 4096);
if (n > 0)
{
buf[n] = 0;
std::cout << buf << std::endl;
}
std::string res = "Server get a message : ";
res += buf;
write(_sockfd, res.c_str(), res.size());
}
}
void Start()
{
for (;;)
{
struct sockaddr_in client;
socklen_t len = sizeof(client);
_sockfd = accept(_listensockfd, (struct sockaddr*)&client, &len); // 创建文件描述符，因为tcp是有连接，面向字节流的，可以通过accept返回值使用read和write来完成通信
if (_sockfd < 0)
{
lg(Fatal, "accept fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "accept successful");
Service();
}
}
~TcpServer()
{
close(_sockfd);
close(_listensockfd);
}
private:
uint16_t _port;
std::string _ip;
int _listensockfd;
int _sockfd;
}; #include "TcpServer.hpp"
#include
int main(int argc, char *argv[])
{
if (argc != 2)
{
std::cout << "port" << std::endl;
exit(-1);
}
uint16_t port = std::atoi(argv[1]);
std::unique_ptr tcp(new TcpServer(port));
tcp->Init();
tcp->Start();
return 0;
} #include
#include
#include
#include
#include
#include
#include
int main(int argc, char *argv[])
{
if (argc != 3)
{
std::cout << "client fail" << std::endl;
exit(-1);
}
std::string ip = argv[1];
uint16_t port = std::stoi(argv[2]);
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
std::cerr << "socket error" << std::endl;
return 1;
}
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(port);
inet_pton(AF_INET, ip.c_str(), &serv.sin_addr.s_addr);
// tcp客户端要不要bind？ 要不要显示的bind？
// 客户端发起connect的时候，进行自动随机bind
socklen_t len = sizeof(serv);
int n = connect(sockfd, (const struct sockaddr*)&serv, len);
if (n < 0)
{
std::cerr << "connect fail" << std::endl;
exit(-1);
}
// 连接成功就可以发送信息了。
std::string msg;
while (true)
{
std::cout << "Please Enter# ";
std::getline(std::cin, msg);
write(sockfd, msg.c_str(), msg.size());
char inbuf[4096];
int n = read(sockfd, inbuf, sizeof(inbuf));
if (n > 0)
{
inbuf[n] = 0;
std::cout << inbuf << std::endl;
}
}
close(sockfd);
return 0;
} 这样就能完成通信了。
下面可以将代码进行一些细节上的处理。
tcp在通信的时候，如果客户端推出了，服务端读取的时候就会读取到0.
可以做一下修改。
当前我们代码开两个客户端的时候，一端发送信息，后连的客户端也发送信息，会阻塞。这是因为目前我们的通信代码是单进程版的通信。一个客户连上去了，另一个客户需要等待。
改为多进程版，这里使用了孙子进程，是一个很妙的想法。
#pragma once
#include
#include
#include
#include
#include
#include
#include "log1.hpp"
Log lg;
const std::string defaultip = "0.0.0.0";
const int backlog = 5;
class TcpServer
{
public:
TcpServer(uint16_t port, const std::string ip = defaultip, int lsfd = -1)
:_port(port)
,_ip(ip)
,_listensockfd(lsfd)
{}
void Init()
{
_listensockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建监听socket的文件描述符
if (_listensockfd < 0)
{
lg(Fatal, "socket fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "socket successful");
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
if (bind(_listensockfd, (const struct sockaddr*)&serv, sizeof(serv)) < 0) // 注册
{
lg(Fatal, "bind fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "bind successful");
if (listen(_listensockfd, backlog) < 0) // 监听
{
lg(Fatal, "listen fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "listen successful");
}
void Service()
{
char buf[4096];
while (true)
{
ssize_t n = read(_sockfd, buf, 4096);
if (n > 0)
{
buf[n] = 0;
std::cout << buf << std::endl;
}
else if (n == 0) // 通信过程中，客户端突然关闭
{
lg(Info, "server close sockfd: %d", _sockfd);
break;
}
else
{
lg(Warning, "read error, sockfd: %d", _sockfd);
break;
}
std::string res = "Server get a message : ";
res += buf;
write(_sockfd, res.c_str(), res.size());
}
}
void Start()
{
for (;;)
{
struct sockaddr_in client;
socklen_t len = sizeof(client);
_sockfd = accept(_listensockfd, (struct sockaddr*)&client, &len); // 创建文件描述符，因为tcp是有连接，面向字节流的，可以通过accept返回值使用read和write来完成通信
if (_sockfd < 0)
{
lg(Fatal, "accept fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "accept successful");
// 单进程
// Service();
// close(_sockfd);
// 多进程
pid_t id = fork();
if (id == 0)
{
// child
close(_listensockfd);
if (fork() > 0) exit(0); // 让孙子进程来处理，这个时候waitpid直接返回，因为父进程挂了，孙子进程会被系统领养。
Service(); // 由子进程做服务
close(_sockfd);
exit(0);
}
// father
close(_sockfd); // 由子进程完成一些任务，子进程会拷贝父进程的文件描述符表，而父进程后续也不对文件进行操作，所以可直接将sockfd关闭
pid_t rid = waitpid(id, nullptr, 0);
(void)rid;
}
}
~TcpServer()
{
close(_listensockfd);
}
private:
uint16_t _port;
std::string _ip;
int _listensockfd;
int _sockfd;
}; 
来了一个新连接，就创建一个进程，这样进程会变得越来越多。但是创建进程的成本是非常高的。
多线程版本
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include "log1.hpp"
Log lg;
const std::string defaultip = "0.0.0.0";
const int backlog = 5;
class TcpServer;
class ThreadData
{
public:
ThreadData(TcpServer *t):ts(t)
{}
~ThreadData()
{}
public:
TcpServer *ts;
};
class TcpServer
{
public:
TcpServer(uint16_t port, const std::string ip = defaultip, int lsfd = -1)
:_port(port)
,_ip(ip)
,_listensockfd(lsfd)
{}
void Init()
{
_listensockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建监听socket的文件描述符
if (_listensockfd < 0)
{
lg(Fatal, "socket fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "socket successful");
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
if (bind(_listensockfd, (const struct sockaddr*)&serv, sizeof(serv)) < 0) // 注册
{
lg(Fatal, "bind fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "bind successful");
if (listen(_listensockfd, backlog) < 0) // 监听
{
lg(Fatal, "listen fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "listen successful");
}
void Service()
{
char buf[4096];
while (true)
{
ssize_t n = read(_sockfd, buf, 4096);
if (n > 0)
{
buf[n] = 0;
std::cout << buf << std::endl;
}
else if (n == 0) // 通信过程中，客户端突然关闭
{
lg(Info, "server close sockfd: %d", _sockfd);
break;
}
else
{
lg(Warning, "read error, sockfd: %d", _sockfd);
break;
}
std::string res = "Server get a message : ";
res += buf;
write(_sockfd, res.c_str(), res.size());
}
}
static void *Routinue(void *args)
{
pthread_detach(pthread_self());
ThreadData *td = static_cast(args);
td->ts->Service();
}
void Start()
{
for (;;)
{
struct sockaddr_in client;
socklen_t len = sizeof(client);
_sockfd = accept(_listensockfd, (struct sockaddr*)&client, &len); // 创建文件描述符，因为tcp是有连接，面向字节流的，可以通过accept返回值使用read和write来完成通信
if (_sockfd < 0)
{
lg(Fatal, "accept fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "accept successful");
// 1.单进程
// Service();
// close(_sockfd);
// 2.多进程
// pid_t id = fork();
// if (id == 0)
// {
// // child
// close(_listensockfd);
// if (fork() > 0) exit(0); // 让孙子进程来处理，这个时候waitpid直接返回，因为父进程挂了，孙子进程会被系统领养。
// Service(); // 由子进程做服务
// close(_sockfd);
// exit(0);
// }
// // father
// close(_sockfd); // 由子进程完成一些任务，子进程会拷贝父进程的文件描述符表，而父进程后续也不对文件进行操作，所以可直接将sockfd关闭
// pid_t rid = waitpid(id, nullptr, 0);
// (void)rid;
// 3.多线程
ThreadData* td = new ThreadData(this);
pthread_t tid;
pthread_create(&tid, nullptr, Routinue, td);
}
}
~TcpServer()
{
close(_listensockfd);
}
private:
uint16_t _port;
std::string _ip;
int _listensockfd;
int _sockfd;
}; 每个客户端到来的时候都需要创建线程，那么，可不可以在线程没有到的时候，提前准备好线程，为可能会连接的客户做准备？
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include "ThreadPool.hpp"
#include "log1.hpp"
#include "Task.hpp"
Log lg;
const std::string defaultip = "0.0.0.0";
const int backlog = 5;
class TcpServer;
class ThreadData
{
public:
ThreadData(TcpServer *t):ts(t)
{}
~ThreadData()
{}
public:
TcpServer *ts;
};
class TcpServer
{
public:
TcpServer(uint16_t port, const std::string ip = defaultip, int lsfd = -1)
:_port(port)
,_ip(ip)
,_listensockfd(lsfd)
{}
void Init()
{
_listensockfd = socket(AF_INET, SOCK_STREAM, 0); // 创建监听socket的文件描述符
if (_listensockfd < 0)
{
lg(Fatal, "socket fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "socket successful");
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(_port);
inet_pton(AF_INET, _ip.c_str(), &serv.sin_addr.s_addr);
if (bind(_listensockfd, (const struct sockaddr*)&serv, sizeof(serv)) < 0) // 注册
{
lg(Fatal, "bind fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "bind successful");
if (listen(_listensockfd, backlog) < 0) // 监听
{
lg(Fatal, "listen fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "listen successful");
}
void Service()
{
char buf[4096];
while (true)
{
ssize_t n = read(_sockfd, buf, 4096);
if (n > 0)
{
buf[n] = 0;
std::cout << buf << std::endl;
}
else if (n == 0) // 通信过程中，客户端突然关闭
{
lg(Info, "server close sockfd: %d", _sockfd);
break;
}
else
{
lg(Warning, "read error, sockfd: %d", _sockfd);
break;
}
std::string res = "Server get a message : ";
res += buf;
write(_sockfd, res.c_str(), res.size());
}
}
static void *Routinue(void *args)
{
pthread_detach(pthread_self());
ThreadData *td = static_cast(args);
td->ts->Service();
}
void Start()
{
ThreadPool::GetInstance()->Start();
for (;;)
{
struct sockaddr_in client;
socklen_t len = sizeof(client);
_sockfd = accept(_listensockfd, (struct sockaddr*)&client, &len); // 创建文件描述符，因为tcp是有连接，面向字节流的，可以通过accept返回值使用read和write来完成通信
if (_sockfd < 0)
{
lg(Fatal, "accept fail, error code: %d , error string: %s", errno, strerror(errno));
exit(-1);
}
lg(Info, "accept successful");
// 1.单进程
// Service();
// close(_sockfd);
// 2.多进程
// pid_t id = fork();
// if (id == 0)
// {
// // child
// close(_listensockfd);
// if (fork() > 0) exit(0); // 让孙子进程来处理，这个时候waitpid直接返回，因为父进程挂了，孙子进程会被系统领养。
// Service(); // 由子进程做服务
// close(_sockfd);
// exit(0);
// }
// // father
// close(_sockfd); // 由子进程完成一些任务，子进程会拷贝父进程的文件描述符表，而父进程后续也不对文件进行操作，所以可直接将sockfd关闭
// pid_t rid = waitpid(id, nullptr, 0);
// (void)rid;
// 3.多线程
// ThreadData* td = new ThreadData(this);
// pthread_t tid;
// pthread_create(&tid, nullptr, Routinue, td);
// 4. 线程池版
Task task(_sockfd);
ThreadPool::GetInstance()->Push(task);
}
}
~TcpServer()
{
close(_listensockfd);
}
private:
uint16_t _port;
std::string _ip;
int _listensockfd;
int _sockfd;
}; #pragma once
#include
#include
#include "log1.hpp"
extern Log lg;
std::string opers="+-*/%";
enum{
DivZero=1,
ModZero,
Unknown
};
class Task
{
public:
Task(int fd):_sockfd(fd)
{}
Task()
{}
void run()
{
char buf[4096];
ssize_t n = read(_sockfd, buf, 4096);
if (n > 0)
{
buf[n] = 0;
std::cout << buf << std::endl;
}
else if (n == 0) // 通信过程中，客户端突然关闭
{
lg(Info, "server close sockfd: %d", _sockfd);
}
else
{
lg(Warning, "read error, sockfd: %d", _sockfd);
}
std::string res = "Server get a message : ";
res += buf;
write(_sockfd, res.c_str(), res.size());
close(_sockfd);
}
void operator ()()
{
run();
}
std::string GetTask()
{
}
~Task()
{
}
private:
int _sockfd;
}; #pragma once
#include
#include
#include
#include
#include
#include
struct ThreadInfo
{
pthread_t tid;
std::string name;
};
static const int defalutnum = 5;
template
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 *tp = static_cast *>(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 *GetInstance()
{
if (nullptr == tp_) // ???
{
pthread_mutex_lock(&lock_);
if (nullptr == tp_)
{
std::cout << "log: singleton create done first!" << std::endl;
tp_ = new ThreadPool();
}
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 &) = delete;
const ThreadPool &operator=(const ThreadPool &) = delete; // a=b=c
private:
std::vector threads_;
std::queue tasks_;
pthread_mutex_t mutex_;
pthread_cond_t cond_;
static ThreadPool *tp_;
static pthread_mutex_t lock_;
};
template
ThreadPool *ThreadPool::tp_ = nullptr;
template
pthread_mutex_t ThreadPool::lock_ = PTHREAD_MUTEX_INITIALIZER; #include "TcpServer.hpp"
#include
int main(int argc, char *argv[])
{
if (argc != 2)
{
std::cout << "port" << std::endl;
exit(-1);
}
uint16_t port = std::atoi(argv[1]);
std::unique_ptr tcp(new TcpServer(port));
tcp->Init();
tcp->Start();
return 0;
} .PHONY:all
all:TcpServer TcpClient
TcpServer:Main.cc
g++ -o $@ $^ -std=c++11 -lpthread
TcpClient:TcpClient.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm TcpClient TcpServer