cpp_concurrency/Programs/06_FuturesPromises/Future_02.cpp at master · pelocpp/cpp_concurrency · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// ===========================================================================
// Future_02.cpp // Promises and Futures
// ===========================================================================

#include "../Logger/Logger.h"

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

namespace PromisesAndFutures02 {

    static void test_shared_future_01()
    {
        Logger::log(std::cout, "Start.");

        std::promise<int> provider;

        // transfer the state
        // from the promise generated future
        // to a shared future
        std::future<int> future{ provider.get_future() };
        std::shared_future<int> sharedFuture{ future.share()};

        std::vector<std::jthread> runners;

        // start a new thread, taking a copy of the future
        runners.push_back(std::jthread([sharedFuture]() {
            // block until the promise is fulfilled
            int value = sharedFuture.get();
            Logger::log(std::cout, "Got result ", value);
            }));

        // start a new thread, taking a copy of the future
        runners.push_back(std::jthread([sharedFuture]() {
            // block until the promise is fulfilled
            int value = sharedFuture.get();
            Logger::log(std::cout, "Got result ", value);
            }));

        std::this_thread::sleep_for(std::chrono::seconds{ 2 });

        // fulfill the promise
        provider.set_value(123);

        Logger::log(std::cout, "Done.");
    }

    // same test scenario - just without a std::vector
    static void test_shared_future_02()
    {
        Logger::log(std::cout, "Start.");

        std::promise<int> provider;

        std::future<int> future{ provider.get_future() };
        std::shared_future<int> sharedFuture{ future.share() };

        // start a new thread, taking a copy of the future
        std::jthread thread1 ([sharedFuture]() {
            int value = sharedFuture.get();
            Logger::log(std::cout, "Got result ", value);
        });

        // start a new thread, taking a copy of the future
        std::jthread thread2([sharedFuture]() {
            int value = sharedFuture.get();
            Logger::log(std::cout, "Got result ", value);
        });

        std::this_thread::sleep_for(std::chrono::seconds{ 2 });

        // fulfill the promise
        provider.set_value(123);

        // watch output of "Done" on the console window
        // std::this_thread::sleep_for(std::chrono::seconds{ 2 });

        Logger::log(std::cout, "Done.");
    }

    // same test scenario - std::vector resides in it's own scope now
    static void test_shared_future_03()
    {
        Logger::log(std::cout, "Start.");

        std::promise<int> provider;

        std::future<int> future{ provider.get_future() };
        std::shared_future<int> sharedFuture{ future.share() };

        {
            std::vector<std::jthread> runners;

            // start a new thread, taking a copy of the future
            runners.push_back(std::jthread([sharedFuture]() {

                int value = sharedFuture.get();
                Logger::log(std::cout, "Got result ", value);
                }));

            // start a new thread, taking a copy of the future
            runners.push_back(std::jthread([sharedFuture]() {

                int value = sharedFuture.get();
                Logger::log(std::cout, "Got result ", value);
                }));

            std::this_thread::sleep_for(std::chrono::seconds{ 2 });

            // fulfill the promise
            provider.set_value(123);
        }

        Logger::log(std::cout, "Done.");
    }
}

void test_future_promise_02()
{
    using namespace PromisesAndFutures02;
    test_shared_future_01();
    test_shared_future_02();
    test_shared_future_03();
}

// ===========================================================================
// End-of-File
// ===========================================================================