问题分析:
有这样一种情况,如下图:
场景描述:
- 客户端发送启动、结束任务的指令给服务器;
- 服务器接收到启动指令之后,开启一个后台线程,便不再“阻塞等待线程执行结果”;实际这个线程指向的结果是我们需要的;
- 服务器收到结束指令时,将后台线程的执行结果返回给客户端;
处理方案一(使用锁mutex):
- 贴代码
// 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更简单。
- C++标准库使用期望(future)来支持一次性事件的等待。要等待某种一次性事件的线程可以获取一个代表该该事件的期望。这个线程可以每隔一段事件周期性的查询这个期望。此外,这个线程也可以继续做其它的处理,直到需要等待这个一次性事件才被挂起。通过期望还可以传递数据。
- 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使用更方便。
小结:
写代码时,要多思考,选择最优方案