\n 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n 10\r\n 11\r\n 12\r\n 13\r\n 14\r\n 15\r\n 16\r\n 17\r\n 18\r\n 19\r\n 20\r\n 21\r\n 22\r\n 23\r\n 24\r\n 25\r\n 26\r\n 27\r\n 28\r\n 29\r\n 30\r\n 31\r\n 32\r\n 33\r\n 34\r\n 35\r\n 36\r\n 37\r\n 38\r\n 39\r\n 40\r\n 41\r\n 42\r\n 43\r\n 44\r\n 45\r\n 46\r\n 47\r\n 48\r\n 49\r\n 50\r\n 51\r\n 52\r\n 53\r\n 54\r\n 55\r\n 56\r\n 57\r\n 58\r\n 59\r\n 60\r\n 61\r\n 62\r\n 63\r\n 64\r\n 65\r\n 66\r\n 67\r\n 68\r\n 69\r\n 70\r\n 71\r\n 72\r\n 73\r\n 74\r\n 75\r\n 76\r\n 77\r\n 78\r\n 79\r\n 80\r\n 81\r\n 82\r\n 83\r\n 84\r\n 85\r\n 86\r\n 87\r\n 88\r\n 89\r\n 90\r\n 91\r\n 92\r\n 93\r\n 94\r\n 95\r\n 96\r\n 97\r\n 98\r\n 99\r\n100\r\n101\r\n102<\/pre>\n<\/td>\n\n\/\/ sleepAndWait.cpp<\/span>\r\n\r\n#include <utility><\/span>\r\n#include <iostream><\/span>\r\n#include <future><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n\r\nstd::mutex coutMutex;\r\n\r\nlong<\/span> double<\/span> getDifference(const<\/span> std::chrono::steady_clock::time_point& tp1,const<\/span> std::chrono::steady_clock::time_point& tp2){\r\n auto<\/span> diff= tp2- tp1;\r\n auto<\/span> res= std::chrono::duration <double<\/span>, std::milli> (diff).count();\r\n return<\/span> res;\r\n}\r\n\r\nvoid<\/span>producer(std::promise<int<\/span>>&& prom){\r\n std::cout << \"PRODUCING THE VALUE 2011\\n\\n\"<\/span>; \r\n std::this_thread::sleep_for(std::chrono::seconds(5));\r\n prom.set_value(2011);\r\n}\r\n\r\nvoid<\/span> consumer(std::shared_future<int<\/span>> fut,std::chrono::steady_clock::duration dur){\r\n auto<\/span> start = std::chrono::steady_clock::now();\r\n std::future_status status= fut.wait_until(std::chrono::steady_clock::now() + dur);\r\n if<\/span> ( status == std::future_status::ready ){\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << std::this_thread::get_id() << \" ready => Result: \"<\/span> << fut.get() << std::endl;\r\n }\r\n else<\/span>{\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << std::this_thread::get_id() << \" stopped waiting.\"<\/span> << std::endl;\r\n }\r\n auto<\/span> end= std::chrono::steady_clock::now();\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << std::this_thread::get_id() << \" waiting time: \"<\/span> << getDifference(start,end) << \" ms\"<\/span> << std::endl;\r\n}\r\n\r\nvoid<\/span> consumePeriodically(std::shared_future<int<\/span>> fut){\r\n auto<\/span> start = std::chrono::steady_clock::now();\r\n std::future_status status;\r\n do<\/span> {\r\n std::this_thread::sleep_for(std::chrono::milliseconds(700));\r\n status = fut.wait_for(std::chrono::seconds(0));\r\n if<\/span> (status == std::future_status::timeout) {\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << \" \"<\/span> << std::this_thread::get_id() << \" still waiting.\"<\/span> << std::endl;\r\n }\r\n else<\/span> if<\/span> (status == std::future_status::ready) {\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << \" \"<\/span> << std::this_thread::get_id() << \" waiting done => Result: \"<\/span> << fut.get() << std::endl;\r\n }\r\n } while<\/span> (status != std::future_status::ready); \r\n auto<\/span> end= std::chrono::steady_clock::now();\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << \" \"<\/span> << std::this_thread::get_id() << \" waiting time: \"<\/span> << getDifference(start,end) << \" ms\"<\/span> << std::endl;\r\n}\r\n\r\nvoid<\/span> consumeWithBackoff(std::shared_future<int<\/span>> fut){\r\n auto<\/span> start = std::chrono::steady_clock::now();\r\n std::future_status status;\r\n auto<\/span> dur= std::chrono::milliseconds(1);\r\n do<\/span> {\r\n std::this_thread::sleep_for(dur);\r\n status = fut.wait_for(std::chrono::seconds(0));\r\n dur *= 2;\r\n if<\/span> (status == std::future_status::timeout) {\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << \" \"<\/span> << std::this_thread::get_id() << \" still waiting.\"<\/span> << std::endl;\r\n }\r\n else<\/span> if<\/span> (status == std::future_status::ready) {\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << \" \"<\/span> << std::this_thread::get_id() << \" waiting done => Result: \"<\/span> << fut.get() << std::endl;\r\n }\r\n } while<\/span> (status != std::future_status::ready);\r\n auto<\/span> end= std::chrono::steady_clock::now();\r\n std::lock_guard<std::mutex> lockCout(coutMutex);\r\n std::cout << \" \"<\/span> << std::this_thread::get_id() << \" waiting time: \"<\/span> << getDifference(start,end) << \" ms\"<\/span> << std::endl;\r\n}\r\n\r\nint<\/span> main(){\r\n \r\n std::cout << std::endl;\r\n\r\n std::promise<int<\/span>> prom;\r\n std::shared_future<int<\/span>> future= prom.get_future();\r\n std::thread<\/span> producerThread(producer,std::move(prom));\r\n \r\n std::thread<\/span> consumerThread1(consumer,future,std::chrono::seconds(4));\r\n std::thread<\/span> consumerThread2(consumer,future,std::chrono::seconds(20));\r\n std::thread<\/span> consumerThread3(consumePeriodically,future);\r\n std::thread<\/span> consumerThread4(consumeWithBackoff,future);\r\n \r\n consumerThread1.join();\r\n consumerThread2.join();\r\n consumerThread3.join();\r\n consumerThread4.join();\r\n producerThread.join();\r\n \r\n std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n <\/p>\n I create in the main function (line 85) the promise, use the promise to create the associated future (line 86), and move the promise to a separate thread (line 87). I have to move the promise in the thread because it doesn’t support copy semantic. That will not hold for the shared futures (lines 89 – 92). They support copy semantics and can therefore be copied.<\/p>\n Before I talk about the work package of the thread, let me say a few words about the auxiliary function getDifference<\/span> (lines 11 – 15). The function takes two-time points and returns the time duration in milliseconds. I will use the function a few times. <\/p>\nWhat about the threads?<\/p>\n \n- producerThread<\/strong>: <\/span>Executes the function producer <\/span>(lines 17 – 21) and publishes its result 2011 after 5 seconds of sleep. This is the result the futures are waiting for.<\/li>\n
- consumerThread1:<\/strong><\/span> Executes the function consumer<\/span> (lines 23 – 37). The thread is waiting for at most 4 seconds (line 25) before continuing its work. This waiting period is not long enough to get the result of the promise.<\/li>\n
- consumerThread2:<\/strong><\/span> Executes the function consumer<\/span> (lines 23 – 37). The thread is waiting at most 20 seconds before continuing its work.<\/li>\n
- consumerThread3:<\/strong><\/span>Executes the function consumePeriodically<\/span> (lines 39 – 57). It sleeps for 700 milliseconds (line 43) and asks for the result of the promise (line 44). Because of the 0 seconds in line 44 (std::chrono::seconds(0)<\/span>) there is no waiting. If the calculation result is available, it will be displayed on line 73.<\/li>\n
- consumerThread4:<\/strong><\/span>Executes the function consumeWithBackoff<\/span> (lines 59 – 79). It sleeps in the first iteration 1 second and doubles by each further iteration its sleeping period. Otherwise, its strategy is similar to consumerThread3.<\/span> <\/span><\/li>\n<\/ul>\n
Now to the synchronization of the program. The clock for determining the current time as std::cout<\/span> are shared variables. But I need no synchronization. First, the method std::chrono::steady_clock::now()<\/span> is thread-safe (for example, in lines 24 and 34); second, the C++ runtime guarantees that the characters will be written thread-safe to std::cout<\/span>. For visual reasons, I used a std::lock_guard<\/span> to wrap std::cout<\/span> (for example, in lines 27, 31, and 35).<\/p>\nAlthough the threads write one after the other to std::cout<\/span> the output is not easy to understand.<\/p>\n<\/span><\/p>\n![\"sleepAndWait\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/09\/sleepAndWait.png\") <\/p>\n
The first output is from the promise. The remaining outputs from the futures. At first, consumerThread4 <\/span>asks for the result. The output is indented by 8 characters. consumerThread<\/span>4 also displays its ID. consumerThread3 is immediately following. Its output is indented by 4 characters. <\/span>The output of consumerThread1<\/span> and consumerThread2<\/span> is not indented.<\/p>\n\n- consumeThread1:<\/strong> <\/span>Waits unsuccessfully 4000.18 ms seconds without getting the result.<\/li>\n
- consumeThread2:<\/strong> <\/span>Gets the result after 5000.3 ms, although its waiting duration is up to 20 seconds.<\/li>\n
- consumeThread3:<\/strong> <\/span>Gets the result after 5601.76 ms. That’s about 5600 milliseconds= 8*7000 milliseconds.<\/li>\n
- consumeThread4: <\/strong><\/span>Gets the result after 8193.81 ms. To say it differently. It waits 3 seconds too long. <\/span><\/li>\n<\/ul>\n
What’s next?<\/h2>\nThis post finishes my miniseries about the time library. I will write about embedded programming with modern C++ in the next post. Here is the overview of my plan.<\/a><\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n","protected":false},"excerpt":{"rendered":" The new time library is an important component of the threading interface. As well, as threads, locks, and condition variables understanding time. All four have in common that they can sleep, wait or block until a time point or for a duration.<\/p>\n","protected":false},"author":21,"featured_media":4959,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[369],"tags":[453],"class_list":["post-4961","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-application","tag-time"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4961","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=4961"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4961\/revisions"}],"predecessor-version":[{"id":6943,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4961\/revisions\/6943"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4959"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4961"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4961"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4961"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}} | | ![\"untilAndForEng\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/09\/untilAndForEng.png\")
<\/p>\n