2022-05-18 使用std::future解决std::thread的局限性（异步等待线程结束、获取一次性事件）

问题分析：

有这样一种情况，如下图：

场景描述：

1. 客户端发送启动、结束任务的指令给服务器；
2. 服务器接收到启动指令之后，开启一个后台线程，便不再“阻塞等待线程执行结果”；实际这个线程指向的结果是我们需要的；
3. 服务器收到结束指令时，将后台线程的执行结果返回给客户端；

---

处理方案一（使用锁mutex）：

1. 贴代码

// future_demo.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <thread>
#include <winsock2.h>
#pragma comment(lib,"ws2_32.lib")

int result = 0;

int calaute_func1(int a)
{
    //得到一个初值，，每过1秒，需要对其进行若干次计时累加
	std::cout << "calaute_func1 thread_id is " << std::this_thread::get_id() << std::endl;
	int index = 5;
    do
    {
        a++;
        std::this_thread::sleep_for(std::chrono::seconds(1));
		std::cout << "calaute_func1 : " << a<< std::endl;
	} while (index--);
	result = a;
	std::cout << "calaute_func1 result is : " << result << std::endl;
    return 0;
}


int main()
{
    std::cout << "Hello World!\n";

	WSADATA a;
	WORD version = MAKEWORD(2, 2);
	WSAStartup(version, &a);
	int sock_fd = 0;
	struct sockaddr_in serv_addr;
	struct sockaddr_in client_addr;
	int addr_len = sizeof(struct sockaddr_in);
	sock_fd = socket(AF_INET, SOCK_STREAM, 0);
	memset(&serv_addr, 0, sizeof(struct sockaddr_in));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = 0;
	serv_addr.sin_port = htons(10001);
	int ret = bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(struct sockaddr_in));
	if (ret == 0) {
		printf("bind ok\n");

	}
	else {
		printf("bind failed\n");
		closesocket(sock_fd);
		return 0;
	}
	ret = listen(sock_fd, 10);
	if (ret == 0)
	{
		printf("listen ok\n");
	}
	else {
		printf("listen failed\n");
		closesocket(sock_fd);
		return 0;
	}
	int clientfd = accept(sock_fd, (sockaddr*)&client_addr, &addr_len);
	if (clientfd)
	{
		unsigned char buf;
		while (1)
		{
			int nRet = recv(clientfd, (char*)&buf, 1, 0);
			if (nRet > 0)
			{
				std::cout << "recv param:" << int(buf) << ",";
				if (int(buf) != 0)
				{
					std::cout << "run calcute thread"<<std::endl;
					std::thread m_thread(calaute_func1, (int)buf);
					//不能等待其返回结果，因为流程需要继续走
					m_thread.detach();
				}
				if (int(buf) == 0)
				{
					std::cout << "Stop calcute thread" << ",the result is "<<result<<std::endl;
					//这个地方需要获取线程的最终计算结果，没有别的办法
					//只能把结果存到线程共享的数据区
					//注意！！！！！！！：当结束指令收到时，线程已经结束，那么结果是正确的；否则是不正确的
					//
				}
			}
		}
	
	}	
	//实际不会走到这步
	closesocket(clientfd);
	closesocket(sock_fd);
	WSACleanup();
	return 0;
	
}

这份代码的运行结果如下所示，很明显不是我们要的，我们应该实现当结束指令到来时，如果线程还没有结束，那么必须要等待线程计算完毕，才能获取最终的“正确结果”。

如何解决呢？用一个互斥量来控制一下，改造如下：


最终运行效果如下，即使收到了客户端的停止指令（0x00），也要等待线程计算出，最终结果后，才得出结果。

---

处理方案一（使用期望future）：

使用方案一明显是不合理的，需要线程之间共享数据，涉及到资源的合理分配、回收、竞争等一些列问题。针对这种场景，使用future更简单。

1. C++标准库使用期望（future）来支持一次性事件的等待。要等待某种一次性事件的线程可以获取一个代表该该事件的期望。这个线程可以每隔一段事件周期性的查询这个期望。此外，这个线程也可以继续做其它的处理，直到需要等待这个一次性事件才被挂起。通过期望还可以传递数据。
2. future使用有两个注意点：future对象最终持有函数的返回值、future对象的get函数会阻塞当前线程直到对象就绪。

上代码：

#include <iostream>
#include <thread>
#include <future>

#include <winsock2.h>

#pragma comment(lib,"ws2_32.lib")



std::future<int> the_result;
//future对象最终持有函数的返回值

int calaute_func1(int a)
{
	//得到一个初值，，每过1秒，需要对其进行若干次计时累加
	
	std::cout << "calaute_func1 thread_id is " << std::this_thread::get_id() << std::endl;
	int index = 5;
	do
	{
		a++;
		std::this_thread::sleep_for(std::chrono::seconds(1));
		std::cout << "calaute_func1 : " << a << std::endl;
	} while (index--);
	
	std::cout << "calaute_func1 result is : " << a << std::endl;
	
	return a;
}




int main()
{
	std::cout << "Hello World!\n";

	WSADATA a;
	WORD version = MAKEWORD(2, 2);
	WSAStartup(version, &a);
	int sock_fd = 0;
	struct sockaddr_in serv_addr;
	struct sockaddr_in client_addr;
	int addr_len = sizeof(struct sockaddr_in);
	sock_fd = socket(AF_INET, SOCK_STREAM, 0);
	memset(&serv_addr, 0, sizeof(struct sockaddr_in));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = 0;
	serv_addr.sin_port = htons(10001);
	int ret = bind(sock_fd, (struct sockaddr*)&serv_addr, sizeof(struct sockaddr_in));
	if (ret == 0) {
		printf("bind ok\n");

	}
	else {
		printf("bind failed\n");
		closesocket(sock_fd);
		return 0;

	}

	ret = listen(sock_fd, 10);
	if (ret == 0)
	{
		printf("listen ok\n");
	}
	else {
		printf("listen failed\n");
		closesocket(sock_fd);
		return 0;
	}
	int clientfd = accept(sock_fd, (sockaddr*)&client_addr, &addr_len);
	if (clientfd)
	{
		unsigned char buf;
		while (1)
		{
			int nRet = recv(clientfd, (char*)&buf, 1, 0);
			if (nRet > 0)
			{
				std::cout << "recv param:" << int(buf) << ",";
				if (int(buf) != 0)
				{
					std::cout << "run calcute thread" << std::endl;
					the_result = std::async(calaute_func1, int(buf));
					//不能等待其返回结果，因为流程需要继续走
					
				}
				if (int(buf) == 0)
				{
					
					std::cout << "Stop calcute thread" << ",the result is " << the_result.get()<< std::endl;
					//future或进行阻塞

				}
			}
		}

	}


	//实际不会走到这步
	closesocket(clientfd);
	closesocket(sock_fd);
	WSACleanup();
	return 0;

}

最终运行结果如下，实现了跟第一种方案一样的效果，但是future使用更方便。

---

小结：

写代码时，要多思考，选择最优方案