![\"TimelineCpp20\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/02\/TimelineCpp20.png\")
<\/p>\nSemaphores are a synchronization mechanism used to control concurrent access to a shared resource. They also allow it to play ping-pong.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
A counting semaphore is a special semaphore with a counter bigger than zero. The counter is initialized in the constructor. Acquiring the semaphore decreases the counter, and releasing the semaphore increases the counter. If a thread tries to acquire the semaphore when the counter is zero, the thread will block until another thread increments the counter by releasing the semaphore.<\/p>\n
The Dutch computer scientist Edsger W. Dijkstra<\/a> presented 1965 the concept of a semaphore. A semaphore is a data structure with a queue and a counter. The counter is initialized to a value equal to or greater than zero. It supports the two operations Originally, a semaphore is a railway signal.<\/p>\n <\/p>\n C++20 supports a <\/p>\n In contrast to a <\/p>\n The constructor call Semaphores are typically used in sender-receiver workflows. For example, initializing the semaphore sem with 0 will block the receiver <\/p>\n <\/p>\n <\/p>\n The Let me make a small performance test by playing ping-pong with semaphores.<\/p>\n In my last post, “Performance Comparison of Condition Variables and Atomics in C++20<\/a>“, I implemented a ping-pong game. Here is the idea of the game: One thread executes a <\/p>\n <\/p>\n <\/p>\n The program <\/p>\n On average, the execution time is 0.33 seconds.<\/p>\n Let me summarize the performance numbers for all ping-pong games. This includes the performance numbers of my last post, “Performance Comparison of Condition Variables and Atomics in C++20<\/a>” and this ping-pong game implemented with semaphores.<\/p>\n Condition variables are the slowest way, and atomic flag the fastest way to synchronize threads. The performance of a wait<\/code> and signal<\/code>. wait<\/code> acquires the semaphore and decreases the counter; it blocks the thread acquiring it if the counter is zero. signal<\/code> releases the semaphore and increases the counter. Blocked threads are added to the queue to avoid starvation<\/a>.<\/p>\n\n![\"semaphore\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/01\/semaphore.jpg\")
<\/p>\n\nThe original uploader was AmosWolfe at English Wikipedia. – Transferred from en.wikipedia to Commons., CC BY 2.0<\/a><\/div>\n <\/div>\n<\/div>\n<\/div>\n<\/div>\nCounting Semaphores in C++20<\/h2>\n
std::binary_semaphore<\/code>, which is an alias for a std::counting_semaphore<1><\/code>. In this case, the least maximal value is 1. std::binary_semaphores<\/code> can be used to implement locks<\/a>.<\/p>\n\nusing<\/span> binary_semaphore =<\/span> std::<\/span>counting_semaphore<<\/span>1<\/span>><\/span>;\r\n<\/pre>\n<\/div>\nstd::mutex<\/code>, a std::counting_semaphore<\/code> is not bound to a thread. This means that the acquire and release call of a semaphore can happen on different threads. The following table presents the interface of a std::counting_semaphore<\/code>.<\/p>\n![\"semaphoreTable\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/01\/semaphoreTable.png\")
<\/p>\n\nstd::counting_semaphore<10> sem(5)<\/code> creates a semaphore sem with a maximal value of 10 and a counter of 5. The call sem.max()<\/code> returns the least maximal value. sem.try_aquire_for(relTime)<\/code> needs a relative time duration; the member function sem.try_acquire_until(absTime)<\/code> needs an absolute time point. In my previous posts, you can read more about time durations and time points to the time library: time<\/a>. The three calls sem.try_acquire, sem.try_acquire_for<\/code>, and sem.try_acquire_until<\/code> return a boolean indicating the success of the calls.<\/p>\nsem.acquire()<\/code> call until the sender calls sem.release()<\/code>. Consequently, the receiver waits for the notification of the sender. A one-time synchronization of threads can easily be implemented using semaphores.<\/p>\n<\/div>\n\n\/\/ threadSynchronizationSemaphore.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <semaphore><\/span>\r\n#include <thread><\/span>\r\n#include <vector><\/span>\r\n\r\nstd::<\/span>vector<<\/span>int<\/span>><\/span> myVec{};\r\n\r\nstd::<\/span>counting_semaphore<<\/span>1<\/span>><\/span> prepareSignal(0<\/span>); \/\/ (1)<\/span>\r\n\r\nvoid<\/span> prepareWork<\/span>() {\r\n\r\n myVec.insert(myVec.end(), {0<\/span>, 1<\/span>, 0<\/span>, 3<\/span>});\r\n std::<\/span>cout <<<\/span> \"Sender: Data prepared.\"<\/span> <<<\/span> '\\n'<\/span>;\r\n prepareSignal.release(); \/\/ (2)<\/span>\r\n}\r\n\r\nvoid<\/span> completeWork<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> \"Waiter: Waiting for data.\"<\/span> <<<\/span> '\\n'<\/span>;\r\n prepareSignal.acquire(); \/\/ (3)<\/span>\r\n myVec[2<\/span>] =<\/span> 2<\/span>;\r\n std::<\/span>cout <<<\/span> \"Waiter: Complete the work.\"<\/span> <<<\/span> '\\n'<\/span>;\r\n for<\/span> (auto<\/span> i:<\/span> myVec) std::<\/span>cout <<<\/span> i <<<\/span> \" \"<\/span>;\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n \r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>thread<\/span> t1(prepareWork);\r\n std::<\/span>thread<\/span> t2(completeWork);\r\n\r\n t1.join();\r\n t2.join();\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n \r\n}\r\n<\/pre>\n<\/div>\nstd::counting_semaphore prepareSignal<\/code> (1) can have the values 0 or 1. The concrete example initializes it with 0 (line 1). This means that the call prepareSignal.release()<\/code> sets the value to 1 (line 2) and unblocks the call prepareSignal.acquire()<\/code> (line 3).<\/p>\n![\"threadSynchronizationSemaphore\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/01\/threadSynchronizationSemaphore.png\")
<\/p>\nA Ping-Pong Game<\/h2>\n
ping<\/code> function and the other thread a pong<\/code> function. <\/code> The ping thread waits for the notification of the pong thread and sends the notification back to the pong thread. The game stops after 1,000,000 ball changes. I perform each game five times to get comparable performance numbers. Let’s start the game:<\/p>\n\n\/\/ pingPongSemaphore.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <semaphore><\/span>\r\n#include <thread><\/span>\r\n\r\nstd::<\/span>counting_semaphore<<\/span>1<\/span>><\/span> signal2Ping(0<\/span>); \/\/ (1)<\/span>\r\nstd::<\/span>counting_semaphore<<\/span>1<\/span>><\/span> signal2Pong(0<\/span>); \/\/ (2)<\/span>\r\n\r\nstd::<\/span>atomic<<\/span>int<\/span>><\/span> counter{};\r\nconstexpr int<\/span> countlimit =<\/span> 1<\/span>'<\/span>000<\/span>'<\/span>000<\/span>;\r\n\r\nvoid<\/span> ping<\/span>() {\r\n while<\/span>(counter <=<\/span> countlimit) {\r\n signal2Ping.acquire(); \/\/ (5)<\/span>\r\n ++<\/span>counter;\r\n signal2Pong.release();\r\n }\r\n}\r\n\r\nvoid<\/span> pong<\/span>() {\r\n while<\/span>(counter <<\/span> countlimit) {\r\n signal2Pong.acquire();\r\n signal2Ping.release(); \/\/ (3)<\/span>\r\n }\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n auto<\/span> start =<\/span> std::<\/span>chrono::<\/span>system_clock::<\/span>now();\r\n\r\n signal2Ping.release(); \/\/ (4)<\/span>\r\n std::<\/span>thread<\/span> t1(ping);\r\n std::<\/span>thread<\/span> t2(pong);\r\n\r\n t1.join();\r\n t2.join();\r\n\r\n std::<\/span>chrono::<\/span>duration<<\/span>double<\/span>><\/span> dur =<\/span> std::<\/span>chrono::<\/span>system_clock::<\/span>now() -<\/span> start;\r\n std::<\/span>cout <<<\/span> \"Duration: \"<\/span> <<<\/span> dur.count() <<<\/span> \" seconds\"<\/span> <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n pingPongsemaphore.cpp<\/code> uses two semaphores: signal2Ping<\/code> and signal2Pong<\/code> (1 and 2). Both can have the two values 0 and 1 and are initialized with 0. This means when the value is 0 for the semaphore signal2Ping,<\/code> a call signal2Ping.release()<\/code> (3 and 4) set the value to 1 and is, therefore, a notification. A signal2Ping.acquire()<\/code> (5) call blocks until the value becomes 1. The same argumentation holds for the second semaphore signal2Pong<\/code>.<\/p>\n![\"pingPongSemaphore\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/01\/pingPongSemaphore.png\")
<\/p>\nAll Numbers<\/h2>\n
std::atomic<\/code> is in between. There is one downside with std::atomic<\/code>. std::atomic_flag<\/code> is the only atomic data type that is always lock-free. Semaphores impressed me most because they are nearly as fast as atomic flags.<\/p>\n![\"PerformanceNumbers\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/01\/PerformanceNumbers.png\")
<\/p>\nWhat’s next?<\/h2>\n