That’s fine as a starting point. A race condition can break the invariance of a program.<\/p>\n
Breaking of invariants<\/h2>\n
In the last post Race Conditions and Data Races<\/a>, I use money transfer between two accounts to show a data race. There was a benign race condition involved. There was also a malicious race condition.<\/p>\n The malicious race condition breaks an invariant of the program. The invariant is, that the sum of all balances should always have the same amount. Which in our case is 200 because each account starts with 100 (1). For simplicity reasons, the unit should be euro. Neither I want to create money by transferring it, nor do I want to destroy it.<\/p>\n <\/p>\n In the beginning, the sum of the accounts is 200 euros. (4) display the sum using printSum<\/span> (3). Line (5) makes the invariant visible. Because there is a short sleep of 1ns<\/span> in line (2), the intermediate sum is 182 euros. In the end, all is fine. Each account has the right balance (6), and the sum is 200 euros (8).<\/p>\n Here is the output of the program.<\/p>\n The malicious story goes on. Let’s create a deadlock by using conditions variables without a predicate.<\/p>\n<\/p>\n Only to make my point clear. You have to use a condition variable in combination with a predicate. For the details, read my post Condition Variables<\/a>. If not, your program may become the victim of a spurious wakeup or lost wakeup.<\/p>\n If you use a condition variable without a predicate, it may happen that the notifying thread sends its notification before the waiting thread is in the waiting state. Therefore, the waiting thread waits forever. That phenomenon is called a lost wake-up.<\/p>\n Here is the program.<\/p>\n <\/p>\n The first invocations of the program work fine. The second invocation locks because the notify call (1) happens before the thread t2<\/span> (2) is in the waiting state (3).<\/p>\n <\/p>\n Of course, deadlocks and livelocks are other effects of race conditions. A deadlock generally depends on the interleaving of the threads, and may sometimes happen or not. A livelock is similar to a deadlock. While a deadlock blocks, I livelock seems to make progress. The emphasis lies on seems. Think about a transaction in a transactional memory use case. Each time the transaction should be committed, a conflict happens. Therefore a rollback takes place. Here is my post about Transactional Memory<\/a>.<\/p>\n Showing lifetime issues of variables is not so challenging.<\/p>\n The recipe of a lifetime issue is quite simple. Let the created thread run in the background and you are half done. That means the creator thread will not wait until its child is done. In this case, you have to be extremely careful that the child is not using something belonging to the creator.<\/p>\n <\/p>\n <\/p>\n This is too simple. The thread t<\/span> is using std::cout<\/span> and the variable mess<\/span>. Both belong to the main thread. The effect is that we don’t see the output of the child thread in the second run. Only “Begin:<\/span>” (2) and “End:<\/span>” (3) are displayed. <\/p>\n I want to emphasize it very explicitly. All the programs in this post are up to this point without a data race. You know it was my idea to write about race conditions and data races. They are related but different concepts.<\/p>\n I can even create a data race without a race condition.<\/p>\n But first, let me remind you what a data race is.<\/p>\n <\/p>\n <\/p>\n 100 threads add 50 euros (3) to the same account (1). They use the function addMoney. <\/span>The critical observation is that the writing to the account is done without synchronization. Therefore we have a data race and no valid result. That is undefined behavior and the final balance (4) differs between 5000 and 5100 euros. <\/span><\/p>\n <\/p>\n\/\/ breakingInvariant.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n\r\nstruct<\/span> Account{\r\n std::<\/span>atomic<<\/span>int<\/span>><\/span> balance{100<\/span>}; \/\/ 1<\/span>\r\n};\r\n \r\nvoid<\/span> transferMoney<\/span>(int<\/span> amount, Account&<\/span> from, Account&<\/span> to){\r\n using<\/span> namespace<\/span> std::<\/span>chrono_literals;\r\n if<\/span> (from.balance >=<\/span> amount){\r\n from.balance -=<\/span> amount; \r\n std::<\/span>this_thread::<\/span>sleep_for(1<\/span>ns); \/\/ 2<\/span>\r\n to.balance +=<\/span> amount;\r\n }\r\n}\r\n\r\n void<\/span> printSum<\/span>(Account&<\/span> a1, Account&<\/span> a2){\r\n std::<\/span>cout <<<\/span> (a1.balance +<\/span> a2.balance) <<<\/span> std::<\/span>endl; \/\/ 3<\/span>\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n Account acc1;\r\n Account acc2;\r\n \r\n std::<\/span>cout <<<\/span> \"Initial sum: \"<\/span>; \r\n printSum(acc1, acc2); \/\/ 4<\/span>\r\n \r\n std::<\/span>thread<\/span> thr1(transferMoney, 5<\/span>, std::<\/span>ref(acc1), std::<\/span>ref(acc2));\r\n std::<\/span>thread<\/span> thr2(transferMoney, 13<\/span>, std::<\/span>ref(acc2), std::<\/span>ref(acc1));\r\n std::<\/span>cout <<<\/span> \"Intermediate sum: \"<\/span>; \r\n std::<\/span>thread<\/span> thr3(printSum, std::<\/span>ref(acc1), std::<\/span>ref(acc2)); \/\/ 5<\/span>\r\n \r\n thr1.join();\r\n thr2.join();\r\n thr3.join();\r\n \/\/ 6<\/span>\r\n std::<\/span>cout <<<\/span> \" acc1.balance: \"<\/span> <<<\/span> acc1.balance <<<\/span> std::<\/span>endl;\r\n std::<\/span>cout <<<\/span> \" acc2.balance: \"<\/span> <<<\/span> acc2.balance <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> \"Final sum: \"<\/span>;\r\n printSum(acc1, acc2); \/\/ 8<\/span>\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n![\"breakingInvariant\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/05\/breakingInvariant.PNG\")
<\/p>\nBlocking issues with race conditions<\/h2>\n
\/\/ conditionVariableBlock.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <condition_variable><\/span>\r\n#include <mutex><\/span>\r\n#include <thread><\/span>\r\n\r\nstd::<\/span>mutex mutex_;\r\nstd::<\/span>condition_variable condVar;\r\n\r\nbool<\/span> dataReady;\r\n\r\n\r\nvoid<\/span> waitingForWork<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> \"Worker: Waiting for work.\"<\/span> <<<\/span> std::<\/span>endl;\r\n\r\n std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> lck(mutex_);\r\n condVar.wait(lck); \/\/ 3<\/span>\r\n \/\/ do the work<\/span>\r\n std::<\/span>cout <<<\/span> \"Work done.\"<\/span> <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n\r\nvoid<\/span> setDataReady<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> \"Sender: Data is ready.\"<\/span> <<<\/span> std::<\/span>endl;\r\n condVar.notify_one(); \/\/ 1<\/span>\r\n\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n std::<\/span>thread<\/span> t1(setDataReady);\r\n std::<\/span>thread<\/span> t2(waitingForWork); \/\/ 2<\/span>\r\n\r\n t1.join();\r\n t2.join();\r\n\r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n \r\n}\r\n<\/pre>\n<\/div>\n![\"conditionVariableBlock\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/05\/conditionVariableBlock.png\")
<\/p>\nLifetime issues of variables<\/h2>\n
\/\/ lifetimeIssues.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <thread><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> \"Begin:\"<\/span> <<<\/span> std::<\/span>endl; \/\/ 2 <\/span>\r\n\r\n std::<\/span>string mess{\"Child thread\"<\/span>};\r\n\r\n std::<\/span>thread<\/span> t([&<\/span>mess]{ std::<\/span>cout <<<\/span> mess <<<\/span> std::<\/span>endl;});\r\n t.detach(); \/\/ 1<\/span>\r\n \r\n std::<\/span>cout <<<\/span> \"End:\"<\/span> <<<\/span> std::<\/span>endl; \/\/ 3<\/span>\r\n\r\n}\r\n<\/pre>\n<\/div>\n![\"lifetimeIssues2\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/05\/lifetimeIssues2.PNG\")
<\/p>\nA data race without a race condition<\/h2>\n
\n
\/\/ addMoney.cpp<\/span>\r\n\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n#include <vector><\/span>\r\n\r\nstruct<\/span> Account{\r\n int<\/span> balance{100<\/span>}; \/\/ 1<\/span>\r\n};\r\n\r\nvoid<\/span> addMoney<\/span>(Account&<\/span> to, int<\/span> amount){\r\n to.balance +=<\/span> amount; \/\/ 2<\/span>\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n Account account;\r\n \r\n std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> vecThreads(100<\/span>);\r\n \r\n \/\/ 3<\/span>\r\n for<\/span> (auto<\/span>&<\/span> thr:<\/span> vecThreads) thr =<\/span> std::<\/span>thread<\/span>( addMoney, std::<\/span>ref(account), 50<\/span>);\r\n \r\n for<\/span> (auto<\/span>&<\/span> thr:<\/span> vecThreads) thr.join();\r\n \r\n \/\/ 4<\/span>\r\n std::<\/span>cout <<<\/span> \"account.balance: \"<\/span> <<<\/span> account.balance <<<\/span> std::<\/span>endl;\r\n \r\n std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n![\"addMoney\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/05\/addMoney.png\")
<\/p>\nWhat’s next?<\/h2>\n