Happy to help :) Please consider subscribing to my channel.

Glad you found it helpful!

Thanks mitgharrib, glad you liked it!

Glad it was helpful! Please subscribe to my channel to get informed when the new content is available!

Great idea! Thanks for the suggestion.

notify_one() from the consumer (and so wait() in producer) is useful because of the possibility of the producer to produce 2 data while the consumer is consuming the first. If there weren't these two because consumer can consume data without possesing the lock (so it can consume while the producer produce another data) the producer could start another cycle of the while loop thus producing another data and overwrite the previous one that the consumer could never touch. It's been 3 years but i answered anyway.

For the purpose i wrote a code that basically implement the consumer-producer logic shown in the video and this is an output with your changes: Main thread started Producer thread started Data produced: 290 Data produced: 575 Data produced: 957 Data produced: 361 Data produced: 924 Data produced: 393 Data produced: 648 Data produced: 169 Data produced: 347 Data produced: 716 Data produced: 8 Data produced: 540 Data produced: 839 Data produced: 109 Data produced: 3 Data produced: 701 Data produced: 643 Data produced: 176 Data produced: 431 Data produced: 864 Data produced: 640 Data produced: 780 Data produced: 733 Data produced: 170 Data produced: 193 Data produced: 102 Data produced: 856 Data produced: 242 Data produced: 129 Data produced: 868 Data produced: 519 Data produced: 388 Data produced: 361 Data produced: 204 Data produced: 944 Data produced: 692 Data produced: 747 Data produced: 915 Data produced: 133 Data produced: 7 Data produced: 572 Data produced: 986 Data produced: 695 Data produced: 347 Data produced: 220 Consumer thread started Data consumed: 220 Data produced: 127 Data produced: 829 Data produced: 500 Data produced: 990 Data produced: 749 Data produced: 694 Data produced: 259 Data produced: 598 Data produced: 100 Data produced: 659 Data produced: 399 Data produced: 483 Data produced: 462 Data produced: 353 Data produced: 910 Data produced: 498 Data produced: 860 Data produced: 759 Data produced: 988 Data produced: 626 Data produced: 930 Data produced: 406 Data produced: 589 Data produced: 946 Data produced: 442 Data produced: 879 Data produced: 710 Data produced: 646 Data produced: 451 Data produced: 41 Data produced: 454 Data produced: 693 Data produced: 259 Data produced: 29 Data produced: 990 Data produced: 712 Data produced: 666 Data produced: 145 Data produced: 319 Data produced: 796 Data produced: 162 Data produced: 381 Data produced: 19 Data produced: 420 Data produced: 405 Data produced: 393 Data produced: 335 Data produced: 855 Data produced: 62 Data produced: 785 Data produced: 169 Data produced: 344 Data produced: 9 Data produced: 370 Data produced: 840 Data produced: 900 Data produced: 790 Data produced: 766 Data produced: 164 Data produced: 645 Producer thread terminated Data consumed: 645 Consumer thread terminated Main thread terminated While this is an output with the producer waiting for the consumer notification: Main thread started Consumer thread started Producer thread started Data produced: 964 Data consumed: 964 Data produced: 597 Data consumed: 597 Data produced: 186 Data consumed: 186 Data produced: 296 Data consumed: 296 Data produced: 620 Data consumed: 620 Data produced: 209 Data consumed: 209 Data produced: 93 Data consumed: 93 Data produced: 228 Data consumed: 228 Data produced: 510 Data consumed: 510 Data produced: 2 Data consumed: 2 Data produced: 709 Data consumed: 709 Data produced: 185 Data consumed: 185 Data produced: 459 Data consumed: 459 Data produced: 452 Data consumed: 452 Data produced: 331 Data consumed: 331 Data produced: 606 Data consumed: 606 Data produced: 680 Data consumed: 680 Data produced: 600 Data consumed: 600 Consumer thread terminated Producer thread terminated Main thread terminated Pretty clear why it's useful now. As you can see way less data are produced in second case (the original) but every data is consumed at least (In each case the program is run for 1 ms).

I have the same doubt, like what is the need of locking again, when it will reach to top after while loop it will get locked automatically by the unique_lock, so why there is need of manual locking

@@sangamchoudhary6977 Becouse of the destructor of unique_lock. if the object ul goes out of scope the destructor call g_mutex.unlock(), and if it does it while g_mutex is already unlocked it will cause an error, so before end of {} lock is required to avoid the error

Because of spurious wake ups. If wait doesn't have a predicate (i.e. checking for ready), the thread might wake up without the producer actually sending a notification. From Wikipedia: "To allow for implementation flexibility in dealing with error conditions and races inside the operating system, condition variables may also be allowed to return from a wait even if not signaled, though it's not clear how many implementations actually do that."......... "Because spurious wakeups can happen whenever there's a race and possibly even in the absence of a race or a signal, when a thread wakes on a condition variable, it should always check that the condition it sought is satisfied. If it's not, it should go back to sleeping on the condition variable, waiting for another opportunity." en.wikipedia.org/wiki/Spurious_wakeup Also see this: stackoverflow.com/questions/8594591/why-does-pthread-cond-wait-have-spurious-wakeups

I think you mean ul.lock(). There is some explanation at 32:29. Quoting from en.cppreference.com/w/cpp/thread/condition_variable/notify_one: "The notifying thread does not need to hold the lock on the same mutex as the one held by the waiting thread(s); in fact doing so is a pessimization, since the notified thread would immediately block again, waiting for the notifying thread to release the lock." In general, it is better to only keep only whatever is needed in the critical section. If you don't have to put something int he critical section (in this case notify_one), it is better to take it out.

@@arisaif Thanks for the link and explanation. From your quoted text, I did not understand the part ".... since the notified thread would immediately block again, waiting for the notifying thread to release the lock". Please can you explain in detail. Thanks in advance.

It is placed on the wait on the conditional variable. The OS sometimes wakes threads up spuriously. Checking the predicate ensures that we pass the wait only when the notification has arrived.

You are correct, if there is no writer at all, no need for a critical section. However, notice that at 19:03, when I mention there is no writer, I mean that when there is no writer **at that moment** in the critical section. In that case multiple readers can be in the critical section. Later on, a writer might decide to write and get into the critical section. Once this happens, no reader can be there and the writer can write. In other words, the critical section provides mutual exclusivity between a set of readers and a single writer.

​@@arisaif Thanks for the clarification. Please post more videos on C++ multithreading.

// if blocked, ul.unlock() is automatically called: This means if the condition is not met (i.e., we have to block and wait), then ul.unlock() is automatically called so that other threads can progress and hopefully set the condition at some point so that we get unblocked. // if unblocked, ul.lock() is automatically called: This means if the condition is met and we can progress, then ul.lock() is automatically called so that other threads cannot get into the critical section. Hope this helps. If you find my channel helpful, please consider subscribing.Thanks!

It doesn't take a long time on my system. Make sure you are compiling with -O3 and also in release mode. You could reduce the number of threads and the number of times we loop. See this example: godbolt.org/z/o7o6frP7x

@@arisaif Thanks. I'm using Visual Studio atm (using a school licence), and unable to find reference to this -o3 thing, so I'm not exactly sure what that is or where to put it. It's not a big deal though, doesn't matter a bit slow. It's just for practice and your tutorials help a lot. Threads and shared resources proved a bit tricky to get right on my own, but this is on point 😅👍

I haven't tested on a system with specifications like yours, but I suspect it just happens to give you the right answer on your machine, but this won't be guaranteed if you move your code to another machine. I suggest you also try it on a different machine or perhaps an online compiler like this: www.onlinegdb.com/online_c++_compiler