std::future, std::async, std::promise ，std::thread

56 阅读 0 评论 37 点赞

我是靠谱客的博主细腻书包，最近开发中收集的这篇文章主要介绍std::future, std::async, std::promise ，std::thread，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

这是 C++ 的新特性；

直接示例说明；

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

int testThread_2()

{

std::cout <<"start start start start start start start start start start start start " << std::endl;

std::this_thread::sleep_for(std::chrono::milliseconds(1000));

std::cout << "stop stop stop stop stop stop stop stop stop stop stop stop " << std::endl;

return 12345;

}

int main()

{

std::future<int> ret = std::async(testThread_2);

std::cout << ret.get() << std::endl;

}

1：

std::async：启动一个线程，不可以用 for 循环启动多个线程，这样会一个线程执行完成，在执行下一个线程；

单挑语句执行，多线程效果；

std::future：获取线程返回结果；

ret.get() ：这个函数会阻塞当前线程，直到 ret 有值；

ret 的值，get（）一次后，无效了；

2：

ret.wait_for(std::chrono::milliseconds(500));

启动线程后，执行这条语句，会让线程先执行 500 毫秒后，在向后执行；

3：

如果觉得 get（）函数可能会长期阻塞函数，可以添加等待超时，非常好用；

std::future<int> ret = std::async(testThread_2); //启动线程；

std::chrono::system_clock::time_point two_seconds_passed = std::chrono::system_clock::now() + std::chrono::seconds(10);

std::future_status ret_fstatus = ret.wait_until(two_seconds_passed); //超时等待；

if (ret_fstatus == std::future_status::ready) //判断超时原因；

{

std::cout << ret.get() << std::endl;

}

else

{

std::cout << "time out，还没有获取结果；" << std::endl;

}

std::cout << "===================================================" << std::endl;

4：

std::promise

这个可以在获取到数值前，阻塞当前线程，直到有值；

std::promise 的价值非常好，以前的 C++ 获取网络消息，需要异步线程获取，然后再通知处理；

现在就可以最简洁高效的写代码；

std::promise<int> g_ret;

void testThread_3()

{

std::cout << "testThread_3 in" << std::endl;

std::this_thread::sleep_for(std::chrono::milliseconds(1000 * 5));

g_ret.set_value(12321);

std::cout << "testThread_3 out" << std::endl;

}

int main()

{

std::future<void> ret = std::async(testThread_3); //启动线程，赋值 g_ret;

std::cout << "g_ret.get_future().get();" << std::endl; //这句会被执行，因为上面只是启动线程；

int n = g_ret.get_future().get(); //这里会阻塞当前线程，直到 g_ret 有值；

可以看出，std::promise 获取 std::future

std::cout << n << std::endl;

}

return 0;

}

关于 std::thread

上述不能代替 std::thread，尤其是关于异步；

这里简单说明几点：

以前的 thread 函数，一般是全局函数，或者类的静态函数，std::thread 更方便一些；

1：可以直接用类的成员函数；

class CTest1

{

public:

CTest1()

{

//注意：这里第二个参数是 this；

pthread_ = new std::thread(&CTest1::thread_test, this, 100);

pthread_->detach();

}

~CTest1()

{

delete pthread_;

pthread_ = 0;

}

private:

std::thread * pthread_;

private:

void thread_test(int m) // thread_test(CMFCApplication3Dlg* pThis)

{

for (int n = 0; n < 1000; n++)

{

SetWindowTextA(AfxGetApp()->GetMainWnd()->GetSafeHwnd(), std::to_string(n).c_str());

std::cout << n << std::endl;

Sleep(10);

}

};

或者：

class CTest
{
public:

   CTest()
   {
       thread_ = std::make_unique<std::thread>(&CTest::thread_test, this);
   }

private:
std::unique_ptr<std::thread> thread_;

private:
   void thread_test() // thread_test(CMFCApplication3Dlg* pThis)
   {
       for (int n = 0; n<1000; n++)
       {
           SetWindowTextA(AfxGetApp()->GetMainWnd()->GetSafeHwnd(), std::to_string(n).c_str());
           std::cout << n << std::endl;

           Sleep(10);
       }
   }

};

2：可以直接用 lambda 表达式作为线程函数；

而且 lambda 表达式可以直接写到 std::thread 构造函数中；

示例1：

这样的线程代码非常简洁

std::thread ([] { printf(std::to_string(n).c_str()); } ).detach();