创建线程thread

相关头文件

#include <windows.h>
#include <WinSock2.h>
#include <WS2tcpip.h>
#include <string>
#include <vector>
#include <time.h>
#include <thread>
#include <map>
using namespace std;

处理函数

int ProcessClientRequest(const char *data, SOCKET socket)
{
	std::map<std::string, std::string> request_data;
	ExtLogger.Out("[%s] Client[%d] [%s]", __FUNCTION__, socket, data);

	int code = ParseCmd(std::string(data), "|", "=", request_data);
	if ((request_data["proxy_id"].size() == 0) || (FALSE == code))
	{
		send(socket, "proxy_id=-1|error_code=1|@*~*@", strlen("proxy_id=-1|error_code=1|@*~*@"), 0);
		ExtLogger.Out("Client[%d] cmd Invalid:proxy_id", socket);

		return code;
	}

	//Get ID
	ProxyID proxyid = (ProxyID)atoi(request_data["proxy_id"].c_str());
	switch (proxyid)
	{
	case PROXYID_SUB_OPEN:
		code = MT4ProxySubOpenBatch(request_data, socket);
		break;
	case PROXYID_SUB_CLOSE:
		code = MT4ProxySubCloseBatch(request_data, socket);
		break;

	default:
		break;
	}

	return code;
}

线程函数（1用于接收命令及参数 2用于发送HTTP报文）

DWORD WINAPI ClientThread()
{
	sockaddr_in remoteAddr;
	int nAddrlen = sizeof(remoteAddr);
	char ipAddrw[32] = { 0 };

	ExtLogger.Out("[%s] ClientThread Started", __FUNCTION__);

	while (flag)
	{
		cliSocket = accept(srvSocket, (SOCKADDR *)&remoteAddr, &nAddrlen);
		if (cliSocket == INVALID_SOCKET)
		{
			ExtLogger.Out("[%s] Accept() Returns Error! WSAGetLastError() = [%d]", __FUNCTION__, WSAGetLastError());
			memset(ipAddrw, 0, sizeof ipAddrw);
			continue;
		}

		InetNtop(AF_INET, (PVOID)(&remoteAddr.sin_addr), ipAddrw, 31);
		ExtLogger.Out("[%s][%d %s] Connected", __FUNCTION__, cliSocket, ipAddrw);
		memset(ipAddrw, 0, sizeof ipAddrw);

		std::string data;
		std::string data1;
		char revData[RECV_BUF_LEN] = { 0 };

		while (true)
		{
			int ret = recv(cliSocket, revData, RECV_BUF_LEN, 0);
			if (ret > 0)
			{
				data1 = revData;
				data += data1;

				const char * tmp = NULL;
				tmp = strstr(data.data(), "@*~*@");
				if (NULL == tmp)
				{
					memset(revData, 0, sizeof revData);
					data1.clear();
				}
				else
				{
					if (data.length() <= RECV_BUF_LEN)
					{
						ProcessClientRequest(data.data(), cliSocket);
						memset(revData, 0, sizeof revData);
						data.clear();
						data1.clear();
					}
					else
					{
						ExtLogger.Out("[%s] Client [%d] receive buffer too large [%d]", __FUNCTION__, cliSocket, data.length());
						break;
					}
				}
			}
			else if (ret == 0)
			{
				ExtLogger.Out("[%s] Client [%d] Has Gracefully Closed The Socket Connection", __FUNCTION__, cliSocket);
				break;
			}
			else
			{
				ExtLogger.Out("[%s] Clinet [%d] Closed due no reason", __FUNCTION__, cliSocket);
				break;
			}
		}

		closesocket(cliSocket);
		cliSocket = INVALID_SOCKET;
	}

	return 0;
}
DWORD WINAPI ClientThreadSubStopOuts()
{
	ExtLogger.Out("[%s] ClientThreadSubStopOuts Started", __FUNCTION__);

	while (flag)
	{
		if (subStopOut.empty())
		{
			Sleep(50);
			continue;
		}

		char strhttppost[MAX_RECEIVE_BUFFER_LEN] = { 0 };
		char sendbuffer[MAX_RECEIVE_BUFFER_LEN] = { 0 };
		char debugbuffer[MAX_RECEIVE_BUFFER_LEN] = { 0 };
		int datalen = 0;
		int sendstopoutordernumber = 0;

		sync_.stopout_Lock();
		clock_t timenow = clock();
		for (size_t i = subStopOut.size(); i > 0; i--)
		{
			if ((timenow - subStopOut[i - 1].timestart) >= 0)
			{
				ExtLogger.Out("[%s] send stopout order #%d ", __FUNCTION__, subStopOut[i - 1].order);
				datalen += sprintf_s(strhttppost + datalen, MAX_RECEIVE_BUFFER_LEN - datalen, "%d,", subStopOut[i - 1].order);
				sendstopoutordernumber++;
				subStopOut[i - 1].timestart += SO_REPORT_PERIOD;
				subStopOut[i - 1].cnt++;
				if (subStopOut[i - 1].cnt >= MAX_SO_REPORT_CNT)
				{
					subStopOut.erase(subStopOut.begin() + (i - 1));
				}
			}
		}
		sync_.stopout_Unlock();

		if (sendstopoutordernumber == 0)
		{
			Sleep(50);
			continue;
		}
		memcpy_s(debugbuffer, MAX_RECEIVE_BUFFER_LEN, strhttppost, MAX_RECEIVE_BUFFER_LEN);
		datalen += sprintf_s(strhttppost + datalen - 1, MAX_RECEIVE_BUFFER_LEN - datalen + 1, " HTTP/1.1\r\n\r\n");

		sprintf_s(sendbuffer, MAX_RECEIVE_BUFFER_LEN, "GET /api/trade/mamSubTrade?sub_oids=%s", strhttppost);

		//
		WSADATA wsa = { 0 };
		WSAStartup(MAKEWORD(2, 2), &wsa);
		SOCKET sockclient = socket(AF_INET, SOCK_STREAM, 0);
		if (sockclient == INVALID_SOCKET)
		{
			ExtLogger.Out("Create Server Listen Socket Error!, WSAGetLastError() = [%d]\r\n", WSAGetLastError());

			Sleep(50);
			continue;
		}

		SOCKADDR_IN addrsrv;

		addrsrv.sin_addr.S_un.S_addr = inet_addr(serverIpAddress);
		addrsrv.sin_family = AF_INET;
		addrsrv.sin_port = htons(6003);

		int a = connect(sockclient, (SOCKADDR*)&addrsrv, sizeof(SOCKADDR));
		if (a == 0)
		{
			ExtLogger.Out("[%s] connect to HTTP Server ok", __FUNCTION__);

			int ret = send(sockclient, sendbuffer, strlen(sendbuffer), 0);
			if (ret <= 0)
			{
				ExtLogger.Out("[%s] send to Server failed, WSAGetLastError() = [%d]", __FUNCTION__, WSAGetLastError());
			}
			ExtLogger.Out("[%s] send to Server success %s ", __FUNCTION__, debugbuffer);

			closesocket(sockclient);
		}
		else
		{
			ExtLogger.Out("[%s] connect to Server failed, WSAGetLastError() = [%d]", __FUNCTION__, WSAGetLastError());
		}

		Sleep(50);
	}

	return 0;
}

主函数启动时调用

flag = TRUE;	
std::thread t1(ClientThread);
t1.detach();
std::thread t2(ClientThreadSubStopOuts);
t2.detach();