std future get_waitkey(0)

全栈程序员站长

发布于 2022-10-04 16:33:45

43400

代码可运行

文章被收录于专栏：全栈程序员必看全栈程序员必看

运行总次数：0

代码可运行

大家好，又见面了，我是你们的朋友全栈君

一、关于std::future成员函数wait_for()：

1.1 关于std::future_status： std::future_status是一个枚举类型，其值有三：

// ENUM future_status
enum class future_status { 
    // names for timed wait function returns
    ready,
    timeout,
    deferred//延迟执行，当std::async()第一个参数为std::lanuch::deferred时生效。
};

1.2 wait_for(): 返回值类型为future_status，该函数将本线程阻塞在当前，并等待一段时间，后继续执行，若在等待时间内wait_for()绑定线程执行完毕，则返回ready，未执行完毕则返回timeout。

int myThread1(int arg)
{ 

cout << arg << endl;
cout << "myThread() START..." << " thread_id:" << std::this_thread::get_id() << endl;
Sleep(5000);
cout << "myThread() END..." << " thread_id:" << std::this_thread::get_id() << endl;
return 5;
}
int main()
{ 

cout << "main thread id:" << std::this_thread::get_id() << endl;
std::future<int>result = std::async(myThread1, 3);
cout << "continue..." << endl;
//枚举类型
std::future_status status = result.wait_for(std::chrono::seconds(3));//设置等待3s,根据设置等待时间与子线程执行消耗时间得到返回值。决定程序在当前行阻塞时间。
if (status == std::future_status::timeout)//子线程还没执行完
{ 

cout << "timeout..." << endl;
//cout << result.get() <<endl;
}
else if (status == std::future_status::ready)//子线程已执行完
{ 

cout << "ready..." << endl;
//cout << result.get() << endl;
}
return 0;
}

关于枚举类型值deferred：

std::future<int>result = std::async(std::launch::deferred,myThread1, 3);

当std::async()第一个参数为std::lanuch::deferred时生效。此时线程不在阻塞在wait_for()处，而是继续执行直到遇见属于该future对象的get()：

	else if (status==std::future_status::deferred)
{ 

cout << "deferred act" << endl;
cout << result.get();
}

注意：无论std::async()是否延迟执行，异步线程都将会指向完程序才能结束，三种结束方式：

阻塞在wait_for()处等待异步线程结束
阻塞在get()处等待异步线程结束
阻塞在return 0;处等待异步线程结束

get()函数只能使用一次，因为get()函数的设计是一个移动语义，相当于将future对象中的值转移到了get()调用者中，所以再次get()就报告了异常。

二、std::shared_future：

也是类模板，其get()函数复制数据。

在实际开发中，有时候某线程的值不止被一个线程所需要，而get()却只能只用一次，这时可以通过std::shared_future达到多次通过get()获取值的目的：

	std::future<int>myf = mypt.get_future();
std::shared_future<int>myf_s(myf.share());
std::thread t2(mythread1,std::ref(myf_s));
t2.join();
auto mysf = myf_s.get();
cout << mysf << " -" << endl;
cout << "---------------" << endl;
auto mysf2 = myf_s.get();
cout << mysf2 << " -" << endl;

如上，用std::future初始化std::shared_future对象，通过std::shared_future即可多次调用get()获取线程返回。

也可不通过std::future连接std::shared_future和packaged_task对象：

//原：
std::future<int>myf = mypt.get_future();
std::shared_future<int>myf_s(myf.share());
//简化：
std::shared_future<int>myf_s = mypt.get_future();

三、原子操作std::atomic： std::atomic来代表原子操作，是个类模板。其实std::atomic是用来封装某个类型的值的

原子操作： 在多线程中不会被打断的程序执行片段。

效率上： 原子操作要比互斥量的方式效率要高。

互斥量的加锁一般是针对一个代码段，而原子操作针对的一般都是一个变量。
原子操作，一般都是指* 不可分割的操作 * ；也就是说这种操作状态要么是完成的，要么是没完成的，不可能出现半完成状态。

注意使用时需要添加#include <atomic>头文件

实例1：计算自增后的值：

std::atomic<int> g_count = 0;
void myThread()
{ 

for (size_t i = 0; i < 10000000; i++)
g_count++;
}
int main()
{ 

std::thread t1(myThread);
std::thread t2(myThread);
t1.join();
t2.join();
cout << g_count << endl;
return 0;
}

实例2：判断线程是否结束

std::atomic<bool> g_ifend = false;
void myThread()
{ 

std::chrono::milliseconds dura(1000);
while (g_ifend==false)
{ 

cout << "thread is working" << "--- " << std::this_thread::get_id() << endl;
std::this_thread::sleep_for(dura);
//Sleep(1);
}
cout << "----- end -----" << "--- " << std::this_thread::get_id() << endl;
}
int main()
{ 

std::thread t1(myThread);
std::thread t2(myThread);
//Sleep(5);
std::chrono::milliseconds dura1(5000);
std::this_thread::sleep_for(dura1);
g_ifend = true;
t1.join();
t2.join();
return 0;
}