用C++实现简单的一对多Socket通讯（二）

回顾

上一篇文章实现了一个最简单的socket连接，但只能进行一对一通讯，所以本篇文章将会将功能扩展下，实现一对多的通讯方式。上篇实现代码中，感谢@rf_versace指出服务器接受数据的容器太小，容易溢出，这点之前没有想到过，目前解决的方法就是设置大一点，一般来说消息都会有序列化和反序列化，关于序列化和反序列化之后再写一篇文章来说下。

一个多线程服务器

和上一篇文章一样，我们初始化socket，设置IP、端口，绑定监听，然后接下来就不一样了，我们不再是阻塞等待客户端->建立连接->接受消息->断开客户端->阻塞等待客户端的形式了，因为我们想与已经连接的客户端保持通讯，所以我们创建一个多线程管理函数，它专门用来分配已连接的socket到一个收发消息的线程，这样客户端就不需要等待上一个socket断开才能连接服务器，从而实现一对多的通讯。

//ServerTest.h
#pragma once		//和#ifdef效果一样
#include <WinSock2.h>
#include <vector>
#include <thread>
#include <mutex>

#pragma comment(lib, "ws2_32.lib")  //加载 ws2_32.dll

typedef struct serverThread
{
	std::thread *t1 = nullptr;
	bool isRuning = false;
	int threadID = -1;
	SOCKET csocket = -1;
}Sthread;

class SocketServerTest
{
public:
	SocketServerTest();
	~SocketServerTest();

	bool CreateSocket();//创建socket
	bool BandSocket(const char* ip, const unsigned short prot);//绑定本地地址和端口号
	bool ListenSocket();//初始化监听并设置最大连接等待数量
	void AcceptSocketManager();//接受请求连接的请求，并返回句柄
	void AddClientSocket(SOCKET &sClient);//循环检查客户端连接
	void ThreadClientRecv(Sthread *sthread);//客户端线程接受数据
	void CloseMySocket();//关闭连接
	void OutputMessage(const char *outstr);//输出文字

private:
	SOCKET m_nServerSocket;//绑定本地地址和端口号的套接口
	std::vector<Sthread*> m_Vecthread;	//保存线程数据的一个vector
	int m_CsocketCount = 0;//线程编号
};

ServerTest.cpp

#include "ServerTest.h"
#include <iostream>

SocketServerTest::SocketServerTest():m_nServerSocket(-1)
{
	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
		OutputMessage("Socket版本错误");
}

SocketServerTest::~SocketServerTest()
{
	CloseMySocket();
}

void SocketServerTest::CloseMySocket()
{
	//退出所有线程
	for (auto it : m_Vecthread)
	{
		it->isRuning = false;
	}

	if (m_nServerSocket != -1)
		closesocket(m_nServerSocket);	//关闭socket连接

	m_nServerSocket = -1;
	WSACleanup();	//终止ws2_32.lib的使用
}

bool SocketServerTest::CreateSocket()
{
	if (m_nServerSocket == -1)
	{
		m_nServerSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);	//设定TCP协议接口;失败返回INVALID_SOCKET
		if (m_nServerSocket != INVALID_SOCKET) 
		{
			OutputMessage("服务器启动成功");
			return true;
		}
	}
	return false;
}

bool SocketServerTest::BandSocket(const char* ip, const unsigned short prot)
{
	int nRet = -1;
	if (m_nServerSocket != -1)
	{
		sockaddr_in Serveraddr;
		memset(&Serveraddr, 0, sizeof(sockaddr_in*));
		Serveraddr.sin_family = AF_INET;
		Serveraddr.sin_addr.s_addr = inet_addr(ip);
		Serveraddr.sin_port = htons(prot);
		nRet = bind(m_nServerSocket, (sockaddr *)&Serveraddr, sizeof(Serveraddr));	//绑定服务器地址和端口号;成功，返回0，否则为SOCKET_ERROR
	}

	if (nRet == 0)
	{
		OutputMessage("绑定IP和端口成功");
		return true;
	}

	OutputMessage("绑定IP和端口失败");
	return false;
}

bool SocketServerTest::ListenSocket()
{
	int nRet = -1;
	if (m_nServerSocket != -1)
	{
		nRet = listen(m_nServerSocket, 5);//设定接受连接的套接字，以及设定连接队列长度;成功返回0，失败返回-1
	}
	if (nRet == SOCKET_ERROR)
	{
		OutputMessage("监听绑定失败");
		return false;
	}
		
	OutputMessage("监听绑定成功");
	return true;
}

void SocketServerTest::AcceptSocketManager()
{
	while (m_nServerSocket != -1)
	{
		sockaddr_in nClientSocket;//如果要保存客户端的IP和端口号，就存在本地
		int nSizeClient = sizeof(nClientSocket);
		SOCKET sClient = accept(m_nServerSocket, (sockaddr*)&nClientSocket, &nSizeClient);//接受客户端连接，阻塞状态;失败返回-1
		if (sClient == SOCKET_ERROR)
		{
			OutputMessage("当前与客户端连接失败");
			return;
		}
		else
		{
			AddClientSocket(sClient);
		}
		Sleep(25);
	}
}

void SocketServerTest::AddClientSocket(SOCKET& sClient)
{
	Sthread *it = new Sthread();
	it->threadID = ++m_CsocketCount;
	it->isRuning = true;
	it->csocket = sClient;
	std::thread t(&SocketServerTest::ThreadClientRecv, this, it);
	t.detach();
	it->t1 = &t;
	m_Vecthread.push_back(it);
	char str[50];
	sprintf_s(str, "%dthread connect is success", it->threadID);
	OutputMessage(str);

	char mess[] = "sercer:与服务器连接成功！";
	send(sClient, mess, sizeof(mess), 0);//发送消息给客户端
}

void SocketServerTest::ThreadClientRecv(Sthread *sthread)
{
	while (sthread->isRuning == true)
	{
		// 从客户端接收数据
		char buff[65535];
		int nRecv = recv(sthread->csocket, buff, 65535, 0);//从客户端接受消息
		if (nRecv > 0)
		{
			char str[50];
			sprintf_s(str, "%dthread send message", sthread->threadID);
			OutputMessage(str);
			OutputMessage(buff);
			char mess[] = "server:收到了你的消息。";
			send(sthread->csocket, mess, sizeof(mess), 0);
		}
		else
		{
			char str[50];
			sprintf_s(str, "ID%d is exit", sthread->threadID);
			OutputMessage(str);
			sthread->isRuning = false;
		}
	}
	return;
}

void SocketServerTest::OutputMessage(const char *outstr)
{
	std::cout << outstr << std::endl;
}

一个多线程客户端

相较于服务器，客户端这边改动有点打，我将接受服务器消息的函数设置成了一个单独的线程，发送服务器消息的函数也被我提出来了。不过总体思路和上篇的没多大区别。

    //multipartiteClientSocket.h
    #pragma once
    #include <WinSock2.h>
    #include <iostream>
    #include <thread>
    
    #pragma comment(lib, "ws2_32.lib")  //加载 ws2_32.dll
    
    typedef struct thread1
    {
    	std::thread *t1 = nullptr;
    	bool isRuning = false;
    } Mythread;
    
    class MultipartiteClientSocketTest
    {
    public:
    	MultipartiteClientSocketTest();
    	~MultipartiteClientSocketTest();
    
    	bool CreateSocket();
    	void CloseSocket();
    
    	bool Myconnect(const char* ip, const unsigned short prot);
    	void Mysend();
    	void Myrecv();
    	bool InitMyrecv();
    
    	void OutputMessage(const char* outstr);
    
    private:
    	char m_message[256];
    
    	SOCKET m_nLocalSocket;
    	Mythread recvThread;
    };
multipartiteClientSocket.cpp
#include "multipartiteClientSocket.h"

MultipartiteClientSocketTest::MultipartiteClientSocketTest()
{
	m_nLocalSocket = -1;
	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
		OutputMessage("Socket版本加载失败");
}

MultipartiteClientSocketTest::~MultipartiteClientSocketTest()
{
	CloseSocket();
}

void MultipartiteClientSocketTest::CloseSocket()
{
	if (m_nLocalSocket != -1)
		closesocket(m_nLocalSocket);	//关闭socket连接

	m_nLocalSocket = -1;
	WSACleanup();	//终止ws2_32.lib的使用
}

//创建一个socket
bool MultipartiteClientSocketTest::CreateSocket()
{
	if (m_nLocalSocket == -1)
	{
		m_nLocalSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
		if (m_nLocalSocket != INVALID_SOCKET)
		{
			OutputMessage("客服端socket启动成功");
			return true;
		}
		else
		{
			OutputMessage("客服端socket启动失败");
			return false;
		}
	}

	OutputMessage("客服端socket已启动");
	return true;
}

bool MultipartiteClientSocketTest::Myconnect(const char* ip, const unsigned short prot)
{
	int nRet = SOCKET_ERROR;
	if (m_nLocalSocket != -1)
	{
		sockaddr_in m_nServeraddr;
		memset(&m_nServeraddr, 0, sizeof(m_nServeraddr));
		m_nServeraddr.sin_family = AF_INET;
		m_nServeraddr.sin_port = htons(prot);
		m_nServeraddr.sin_addr.s_addr = inet_addr(ip);
		nRet = connect(m_nLocalSocket, (sockaddr*)&m_nServeraddr, sizeof(m_nServeraddr));//成功返回0。否则返回SOCKET_ERROR

		if (nRet == SOCKET_ERROR)
		{
			OutputMessage("服务器连接失败！");
			return false;
		}

		OutputMessage("服务器连接成功！");
		InitMyrecv();

		return true;
	}

	return false;
}

bool MultipartiteClientSocketTest::InitMyrecv()
{
	if (m_nLocalSocket == -1)
		return false;

	if (recvThread.t1 == nullptr)
	{
		recvThread.isRuning = true;
		std::thread t(&MultipartiteClientSocketTest::Myrecv, this);
		t.detach();
		recvThread.t1 = &t;
	}
	else
	{
		OutputMessage("recvThread is failed！");
		return false;
	}

	Mysend();

	return true;
}

void MultipartiteClientSocketTest::Myrecv()
{
	if (m_nLocalSocket != -1)
	{
		int resultRecv = -1;
		while (recvThread.isRuning == true)
		{
			resultRecv = recv(m_nLocalSocket, m_message, sizeof(m_message), 0);
			if (resultRecv > 0)
			{
				//输出消息
				OutputMessage(m_message);
				memset(m_message, '\0', sizeof(m_message));
			}
			else
			{
				//这几种错误码，认为连接是正常的，继续接收
				if ((resultRecv < 0) && (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR))
				{
					continue;//继续接收数据
				}
				OutputMessage("与服务器连接中断！");
				break;//跳出接收循环
			}
		}
	}
	else
	{
		OutputMessage("当前与服务器未连接！");
	}
	recvThread.t1 = nullptr;
	return;
}

void MultipartiteClientSocketTest::Mysend()
{
	if (m_nLocalSocket != -1)
	{
		char tempstr[256];
		while (std::cin >> tempstr)
		{
			send(m_nLocalSocket, tempstr, sizeof(tempstr), 0);
		}
	}
	else
	{
		OutputMessage("当前与服务器未连接");
	}
	return;
}

void MultipartiteClientSocketTest::OutputMessage(const char * outstr)
{
	std::cout << outstr << std::endl;
}

先启动服务器，在启动多个客户端，然后效果如下

总结

虽然解决了一对多的问题，但是当有大量客户端连接服务器的时候，你就需要开这么多线程来对应客户端连接，而如此多的线程必定会大大降低效率，所以这种方式是不科学的。那我们能不能在一个或几个线程里来处理这么多客户端连接呢？答案肯定是：能。也就是大家所说的IO多路复用。因为在windows的环境，所以下一篇会写一个select模型的socket通讯。