1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <queue>


std::condition_variable messages_cv;
std::mutex messages_mtx;
std::queue<std::string> messages;

std::atomic_bool running = true; // TODO: stop_token when c++20


void pull_messages_thread() {
    bool should_run = running;
    while (should_run) {
        std::unique_lock lock(messages_mtx);
    
        messages_cv.wait(lock, []{ return !messages.empty() || !running; });
        if (messages.empty()) return;
    
        auto message = std::move(messages.front());
        messages.pop();
    
        should_run = running || !messages.empty();
        lock.unlock();
    
        std::cout << "Processing\t" + message + "\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
        std::cout << "Processed\t" + message + "\n";
    }
}


int main() {
    std::thread puller(pull_messages_thread);
    for (std::size_t i = 0; i < 10; ++i) {
        std::string message = "Message<" + std::to_string(i) + ">";

        std::unique_lock lock(messages_mtx);
        std::cout << "Storing \t" + message + "\n";
        messages.emplace(std::move(message));
        lock.unlock();
        messages_cv.notify_all();

        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }

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

    running = false;
    messages_cv.notify_all();
    puller.join();
}

/*

Storing 	Message<0>
Processing	Message<0>
Storing 	Message<1>
Storing 	Message<2>
Processed	Message<0>
Processing	Message<1>
Storing 	Message<3>
Processed	Message<1>
Processing	Message<2>
Storing 	Message<4>
Storing 	Message<5>
Processed	Message<2>
Processing	Message<3>
Storing 	Message<6>
Storing 	Message<7>
Processed	Message<3>
Processing	Message<4>
Storing 	Message<8>
Storing 	Message<9>
Processed	Message<4>
Processing	Message<5>
Processed	Message<5>
Processing	Message<6>
Processed	Message<6>
Processing	Message<7>
Processed	Message<7>
Processing	Message<8>
Processed	Message<8>
Processing	Message<9>
Processed	Message<9>

 */