【C++并发与多线程】 10_shared_future、automic

std::shared_future

类模板

template   shared_future;
template  shared_future;   // specialization : T is a reference type (R&)
template <>         shared_future; // specialization : T is void

• 一个 shared_future 对象行为类似于 future 对象，除了它可以被赋值，而且一个以上的 shared_future 可以在他们的共享状态结束时共享所有权。它们还被允许一旦准备好就多次检索共享状态下的值。
• shared_future 对象可以从 future 对象隐式转换，也可以通过 future::share 显式获得。在这两种情况下，原 future 对象自身将失效。
• 共享状态的生存期至少要持续到与之关联的最后一个对象被销毁为止。从 shared_future 中获取值（使用成员函数 get） 不会释放其对共享状态的所有权（与 future 不同）。因此，如果与 shared_future 对象相关联，则共享状态可以在最初获得它的对象（如果有的话）之后继续存在。

成员函数	描述
get	当共享状态就绪时，返回存储在共享状态中的值的引用（或引发其异常）
valid	检查 shared_future 对象是否与共享状态关联
wait	等待共享状态准备就绪
wait_for	等待共享状态在 rel_time 指定的时间内准备就绪
wait_until	等待共享状态准备就绪，最多直到abs_time时间点

#include 
#include 
#include 

using namespace::std;

int mythread()
{
    cout << "mythread begin" << endl;

    this_thread::sleep_for(chrono::microseconds(5000));

    cout << "mythread end" << endl;

    return 5;
}

int main()
{
    cout << "main begin" << endl;

    future result = async(launch::async, mythread);
    shared_future result_s = result.share();

    // 等价
    // shared_future result_s = async(launch::async, mythread);

    if (result_s.valid())
    {
        cout << result_s.get() << endl;

        cout << result_s.get() << endl;

        cout << result_s.get() << endl;
    }

    cout << "main end" << endl;

    return 0;
}

输出：

main begin
mythread begin
mythread end
5
5
5
main end

std::atomic 原子操作

类模板

template  struct atomic;

• 原子操作是指不会被线程调度机制打断的操作。这种操作一旦开始，就一直运行到结束，中间不会有任何任何上下文切换。
• 原子操作可以是一个步骤，也可以是多个操作步骤，但其顺序不可被打乱，也不可以被切合只执行其中一部分。
• 将整个操作视作一个整体是原子操作的核心特征。

编程实验

• 非原子操作，不加锁，效率很高，但无法得到正确的结果
• 非原子操作，加锁，效率很低，但结果正确
• 原子操作，效率很高，且结果正确

测试1：非原子操作，无锁

#include 
#include 

using namespace::std;

int g_sum = 0;

void add()
{
    for (uint32_t i=0; i<10000000; ++i)
        ++g_sum;
}

int main()
{
   auto beginTime = clock();

   thread t1(add);
   thread t2(add);

   t1.join();
   t2.join();

   auto endTime = clock();

   cout << "time consuming  : " << endTime - beginTime << endl;
   cout << "calculated value: " <<  g_sum << endl;

    return 0;
}

输出：[速度快，结果错误]

time consuming  : 47
calculated value: 10856025

测试2：非原子操作，有锁

#include 
#include 
#include 

using namespace::std;

int g_sum = 0;
mutex g_mutex;

void add()
{
    for (uint32_t i=0; i<10000000; ++i)
    {
        g_mutex.lock();
        ++g_sum;
        g_mutex.unlock();
    }
}

int main()
{
   auto beginTime = clock();

   thread t1(add);
   thread t2(add);

   t1.join();
   t2.join();

   auto endTime = clock();

   cout << "time consuming  : " << endTime - beginTime << endl;
   cout << "calculated value: " <<  g_sum << endl;

    return 0;
}

输出：[结果正确，速度慢]

time consuming  : 571
calculated value: 20000000

测试3：原子操作

#include 
#include 
#include 

using namespace::std;

atomic g_sum {0};

void add()
{
    for (uint32_t i=0; i<10000000; ++i)
    {
        ++g_sum;
    }
}

int main()
{
   auto beginTime = clock();

   thread t1(add);
   thread t2(add);

   t1.join();
   t2.join();

   auto endTime = clock();

   cout << "time consuming  : " << endTime - beginTime << endl;
   cout << "calculated value: " <<  g_sum << endl;

    return 0;
}

输出：[速度快，结果正确]

time consuming  : 292
calculated value: 20000000

一般用法

• 用于多线程环境中的访问标记
• 用于多线程环境中的访问统计

#include 
#include 
#include 

using namespace::std;

atomic g_ifEnd {false};

void mythread()
{
    cout << "mythread begin" << endl;

    chrono::microseconds dura(1000);

    while (!g_ifEnd)
    {
        cout << "mythread thread id :" << this_thread::get_id() << endl;

        this_thread::sleep_for(dura);
    }

    cout << "mythread begin" << endl;
}

int main()
{
   cout << "main end" << endl;

   thread t1(mythread);

   this_thread::sleep_for(chrono::microseconds(5000));

   g_ifEnd = true;

   t1.join();

   cout << "main end" << endl;

    return 0;
}

输出：

main end
mythread begin
mythread thread id :2
mythread begin
main end