Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

Understanding Mutex in C++ (Multithreading for Beginners) | Mutual Exclusion Explained

Added: 2026-08-11

Deep Dive

Basic understanding of multithreading concepts, specifically how to spawn and manage threads using 'std::thread' in C++.

Modern C++: Multi-threading, thread class, spawning, synchronization

Modern C++: Multi-threading, thread class, spawning, synchronization

1.6K

Multi-threading enables parallel execution of tasks within a single process, where tasks run concurrently rather than in true parallelism. The main function executes as the main thread, which can spawn child threads using the std::thread class. Creating threads requires specifying the task function and parameters. Child threads must be joined back to the main thread using join() to prevent runtime errors. The process of creating threads is called spawning, while joining them is called synchronization. Multi-threading produces non-deterministic output because threads access shared resources concurrently. A thread created without an associated task is called an empty thread and is not joinable. The joinable() function checks if a thread is joinable. Always check joinability before calling join() to prevent errors.

Click to watch →

Threads - Part 15 of Idiomatic Rust in Simple Steps

Threads - Part 15 of Idiomatic Rust in Simple Steps

1.5K

To spawn a thread, use `std::thread::spawn`. This returns a `JoinHandle` that ties the spawned thread to the parent thread. If the `JoinHandle` is dropped, the thread becomes orphaned and may still run, but the process ends when main completes. The inconsistency in thread execution timing is due to the operating system scheduler.

Click to watch →

Multithreading, Message Passing (crossbeam-channel), Arc/Mutex, and Send/Sync - Rust

Multithreading, Message Passing (crossbeam-channel), Arc/Mutex, and Send/Sync - Rust

6.7K

Thread spawn creates new threads by passing closures, enabling concurrent execution. Thread sleep (std::thread::sleep) yields CPU time to other threads, allowing interleaving. Even short sleep durations (1ms) can cause data races due to thread interleaving. Thread join waits for spawned threads to complete before continuing, preventing premature exit and enabling synchronization between threads. Without join, spawned thread work may be lost if the main thread exits first.

Click to watch →

C++ std::thread Introduction

C++ std::thread Introduction

9K

Multi-threading enables parallel execution on multi-core processors by dividing tasks into independent units of work. Key concepts include: (1) Threads represent concurrent execution paths, (2) Multi-core CPUs benefit from parallel processing, (3) Divide-and-conquer strategy splits problems into smaller portions, (4) Three essential steps: creating threads, distributing work, and combining results. C++ threads are created using std::thread with function pointers and arguments. Main thread creates child threads that execute concurrently. The join() method synchronizes threads by blocking until completion. Dynamic thread creation uses command-line arguments and vectors for heap-allocated thread objects. Memory management requires explicit deletion for heap-allocated threads. Unsynchronized threads produce interleaved output, demonstrating concurrent execution.

Click to watch →

Back to Basics: C++ Concurrency - David Olsen - CppCon 2023

Back to Basics: C++ Concurrency - David Olsen - CppCon 2023

25.1K

std::thread creates new threads by passing callables and arguments to its constructor. The constructor returns immediately after scheduling, enabling asynchronous execution. Parent threads continue running while child threads execute concurrently. To wait for completion, call join(); to detach a thread, call detach(). You must call either before the thread object goes out of scope, or the destructor calls std::terminate(). Thread creation and join are synchronization points: changes in the parent before creation are visible to children, and changes in children are visible to parents after join returns.

Click to watch →

Deep Dive

The concept of shared memory space in concurrent programming and why multiple threads accessing the same data can lead to data races.

Back to Basics: Concurrency - Mike Shah - CppCon 2021

Back to Basics: Concurrency - Mike Shah - CppCon 2021

35.6K

A data race occurs when multiple threads access shared data concurrently, and at least one thread is writing to the data. The result depends on the order of execution, making the program non-deterministic. For example, if two threads increment a shared counter simultaneously, the final value may be incorrect because both read the old value before either writes back.

Click to watch →

L8 Shared Memory in GPUs #cuda #gpucomputing #nvidiagpus

L8 Shared Memory in GPUs #cuda #gpucomputing #nvidiagpus

1.2K

When multiple threads concurrently access and modify shared memory locations, data race conditions occur. For example, if thread A reads m[i][j] and thread B reads m[i][j+1], both may read stale values before writing back results. Two synchronization points are essential: (1) between copying data from global memory to shared memory and starting computations, and (2) between completing computations and copying results back to global memory. Without synchronization, threads may execute out of order, leading to incorrect results.

Click to watch →

Basic Thread Mechanisms

Basic Thread Mechanisms

19.4K

Unlike processes, threads share the same virtual-to-physical address mappings within a single address space. This allows multiple threads to legally access the same physical memory using identical virtual addresses. However, this sharing introduces concurrency problems: if two threads simultaneously read and modify shared data, inconsistencies can occur. One thread may read garbage while another modifies data, or overlapping updates from both threads can corrupt shared state.

Click to watch →

Параллелизм в вебе — что это и зачем? (Дмитрий Злыгин, DINS)

Параллелизм в вебе — что это и зачем? (Дмитрий Злыгин, DINS)

283

When multiple threads access shared memory simultaneously, race conditions can occur where concurrent operations produce incorrect results. For example, incrementing a shared counter from multiple threads may produce incorrect totals because operations like read-modify-write are not atomic. Without proper synchronization, concurrent access to shared memory can lead to data corruption and inconsistent results.

Click to watch →

Introduction to threads, mutex_locks and race conditions in C, ELI5

Introduction to threads, mutex_locks and race conditions in C, ELI5

5.4K

Race conditions occur when multiple threads access shared data simultaneously without synchronization, causing unpredictable results. In the Starbucks analogy, multiple waiters (threads) trying to update a shared ledger (global variable) can cause data corruption because they read the same value, process it independently, and write back inconsistent results. This is an intra-process phenomenon that only occurs between threads sharing the same memory space.

Click to watch →

Deep Dive

Familiarity with the RAII (Resource Acquisition Is Initialization) paradigm in C++, as it is fundamental to how lock managers function.

Back to Basics: Concurrency - Mike Shah - CppCon 2021

Back to Basics: Concurrency - Mike Shah - CppCon 2021

35.6K

Lock guards (std::lock_guard) use the RAII (Resource Acquisition Is Initialization) pattern to automatically manage locks. When a lock guard is created, it acquires the lock; when it goes out of scope, it releases the lock. This handles exceptions and ensures locks are always released, preventing deadlocks caused by forgotten unlocks.

Click to watch →

How Is RAII Used In C++? - Next LVL Programming

How Is RAII Used In C++? - Next LVL Programming

171

RAII (Resource Acquisition Is Initialization) is a fundamental C++ technique that ties resource lifecycle to object lifecycle. Resources are acquired in constructors and released in destructors, eliminating manual memory management. Key applications include file streams (open in constructor, close in destructor), smart pointers (unique_ptr, shared_ptr for automatic memory deletion), and lock management in multi-threaded applications. RAII prevents resource leaks, double deletes, and ensures cleanup even during exceptions. While Rust uses ownership/borrowing, both languages share the core principle of binding resource cleanup to object lifetime. This technique is essential for safe, maintainable systems programming.

Click to watch →

Многопоточность для олимпиадников

Многопоточность для олимпиадников

1.1K

RAII (Resource Acquisition Is Initialization) is a C++ pattern where resources are acquired in constructors and released in destructors. For mutexes, this means creating a lock guard object that automatically locks the mutex when created and unlocks it when destroyed. This ensures that locks are always released, even if exceptions occur, preventing deadlocks.

Click to watch →

C++ Best Practices: RAII

C++ Best Practices: RAII

21.5K

LockGuard implements RAII for mutex locks by creating an object that automatically releases the lock when it goes out of scope. This prevents deadlocks caused by forgetting to unlock, as the destructor ensures the lock is always released even if an exception is thrown or the function returns early.

Click to watch →

Back to Basics: RAII in C++ - Andre Kostur - CppCon 2022

Back to Basics: RAII in C++ - Andre Kostur - CppCon 2022

33.1K

RAII is a C++ idiom where resources are acquired during an object's constructor and released during its destructor, ensuring automatic resource management without manual intervention; this approach solves common resource management problems like leaks, use-after-disposal, and double disposal by leveraging C++'s automatic object lifetime management, and the standard library provides several RAII classes such as std::lock_guard, std::unique_ptr, and std::jthread that implement this pattern for common resources.

Click to watch →

Deep Dive

General C++ proficiency, including working with standard library containers, scopes, and destructors.

Interview With a University of Michigan Student - Easy Difficulty - No Hire

Interview With a University of Michigan Student - Easy Difficulty - No Hire

2.3K

For C++ interviews, you should be comfortable with: (1) pointer manipulation, (2) memory management (new/delete), (3) standard library containers (std::list, std::map), (4) implementing data structures from scratch. Being able to implement data structures from scratch demonstrates deeper understanding and is often expected in interviews.

Click to watch →

Update [Moving] 2017/06/16

Update [Moving] 2017/06/16

3.2K

The tutorial series covers dynamic heap allocation using new and delete operators, with emphasis on destructors and RAII (Resource Acquisition Is Initialization) as core C++ concepts. The series will transition from custom implementations to standard library components including string, vector, cin, cout, and insertion operators. Vector will replace C arrays as the primary dynamic container. After completing the console arc, the series will return to graphics programming using the Chili framework, covering bitmap loading, sprite operations, animated sprites, and text rendering.

Click to watch →

oop 2

oop 2

203

This section covers Destructor fundamentals and scope management in C++. The Destructor (~ClassName()) automatically executes when an object is destroyed, performing cleanup operations. It cannot have parameters or be overloaded. The section explains scope rules: variables declared inside a scope exist only within that scope and are automatically destroyed when the scope ends. Objects are destroyed in reverse order of creation (Last In, First Out). This ensures proper resource cleanup, especially important when objects hold references to other objects. The section demonstrates how scope exit triggers Destructor execution for all objects within that scope.

Click to watch →

Поддержка идиомы RAII средствами стандартной библиотеки С++ // Курс «C++ Developer. Basic»

Поддержка идиомы RAII средствами стандартной библиотеки С++ // Курс «C++ Developer. Basic»

115

STL dynamic containers like std::vector and std::string are RAII-compliant by default. They allocate memory in constructors and release it in destructors. When a container goes out of scope, its destructor automatically frees all dynamically allocated memory. This eliminates the need for manual delete calls and ensures cleanup even when exceptions occur or early returns happen. The container's destructor handles all cleanup automatically.

Click to watch →

Back to Basics: Standard Library Containers in Cpp - Rainer Grimm - CppCon 2022

Back to Basics: Standard Library Containers in Cpp - Rainer Grimm - CppCon 2022

10.1K

The C++ Standard Library provides three container categories: sequence containers (array, vector, deque, list, forward_list), ordered associative containers (map, multimap, set, multiset), and unordered associative containers (C++11+). All containers share a common interface including construction, assignment, size queries, iteration, and comparison operators. They use value semantics, meaning containers own their elements and manage their lifetimes. Construction methods include default, size-based, range, copy/move, and initializer_list constructors. C++20 added erase_if for predicate-based removal. Range-based for loops simplify iteration with auto& enabling element modification. Comparison operators enable lexicographical ordering, working only between containers of the same type.

Click to watch →

Mutex Basics

Real-life Analogy

Code Problem

Lock Solution

Lock Guard

Unique Lock vs Guard

Mutex Basics

0:00

Playing Section

1
Defines mutex as mutual exclusion for thread safety.
2
Prevents simultaneous access to shared code.

Deep Dive

Understanding Deadlocks and prevention techniques, such as lock ordering and using C++17's 'std::scoped_lock' to lock multiple mutexes safely.

The 1 Line of C++ That Makes Deadlocks Physically Impossible

The 1 Line of C++ That Makes Deadlocks Physically Impossible

103

In C++, using std::lock or std::scoped_lock (C++17) prevents deadlocks when locking multiple mutexes by atomically acquiring all locks simultaneously, eliminating the need for programmers to manually manage lock order and preventing circular wait conditions that cause deadlocks.

Click to watch →

DBMS: Locking Protocols, Two Phase locking(2PL), upgraded 2PL, Strict 2PL by Rekha Kushwaha

DBMS: Locking Protocols, Two Phase locking(2PL), upgraded 2PL, Strict 2PL by Rekha Kushwaha

115

Lock ordering prevents deadlocks by enforcing a global order for acquiring locks. Transactions must acquire locks in a predetermined sequence (e.g., by data item ID). If a transaction attempts to acquire a lock already held by another transaction, it must wait. This prevents circular wait conditions that cause deadlocks. The lock ordering ensures all transactions acquire locks in the same sequence, eliminating circular dependencies. Without lock ordering, two transactions can deadlock if each holds a lock on a different item and each wants to acquire a lock held by the other.

Click to watch →

10. Углублённое программирование на C/C++. Многопоточность | Технострим

10. Углублённое программирование на C/C++. Многопоточность | Технострим

13.3K

Deadlocks occur when threads hold locks each other needs, creating circular wait. Prevention requires consistent lock ordering across all threads or using std::lock() which atomically acquires multiple locks with retry logic. std::scoped_lock<T...> provides RAII-based multi-lock acquisition with automatic unlocking. Timed lock acquisition (try_lock_for, try_lock_until) prevents indefinite blocking using monotonic clocks.

Click to watch →

std lock In C++

std lock In C++

23.3K

The std::lock function in C++11 is a blocking call that locks multiple mutexes simultaneously in a deadlock-free manner by trying to lock all provided mutexes and automatically rearranging the locking order if any mutex cannot be acquired, thus preventing deadlock situations that could occur when different threads lock mutexes in different orders.

Click to watch →

C++ lectures at MIPT (in Russian). Lecture 12. Concurrency, part 1

C++ lectures at MIPT (in Russian). Lecture 12. Concurrency, part 1

3.8K

A simple solution to the Dining Philosophers Problem uses a loop where each philosopher picks up the left fork, then attempts to pick up the right fork. If successful, they eat; otherwise, they release the left fork and retry. This solution prevents deadlock but may cause starvation. std::scoped_lock is a C++17 feature that acquires multiple mutexes atomically, preventing deadlock. It uses a try_lock mechanism to acquire all locks simultaneously. If any lock cannot be acquired, none are acquired. This provides a safer alternative to manual lock ordering.

Click to watch →

Deep Dive

Thread communication using condition variables ('std::condition_variable') to synchronize the execution order of threads.

10. Углублённое программирование на C/C++. Многопоточность | Технострим

10. Углублённое программирование на C/C++. Многопоточность | Технострим

13.3K

Condition variables (std::condition_variable) allow threads to wait for specific conditions to become true. A thread calls wait() on a condition variable, which atomically releases the associated mutex and blocks the thread. Another thread can signal the condition variable using notify_one() or notify_all() to wake waiting threads. Condition variables are used for producer-consumer patterns and other synchronization scenarios where threads need to wait for events.

Click to watch →

Multithreading in C++20: A Beginner's Guide to Concurrency

Multithreading in C++20: A Beginner's Guide to Concurrency

Mutexes provide mutual exclusion but reduce scalability by creating serial sections. std::scoped_lock handles multiple mutexes safely, preventing deadlocks by locking all passed mutexes in a deadlock-free order. std::condition_variable enables efficient waiting without busy-waiting: use with std::unique_lock to unlock while waiting, then relock and check predicates. The library may call predicates multiple times, ensuring correctness even with spurious wakeups. Always release locks immediately after notifying to minimize contention and allow waiting threads to proceed promptly.

Click to watch →

Rob Stewart: Survey of Multi-Threaded Programming Support in C++11 and Boost

Rob Stewart: Survey of Multi-Threaded Programming Support in C++11 and Boost

1.9K

Condition variables coordinate threads waiting for state changes. The pattern involves: (1) changer acquires mutex, modifies state, calls notify_one/notify_all; (2) waiter acquires mutex, waits on condition variable, examines state. The predicate version handles spurious wakeups by retrying until the condition is truly satisfied.

Click to watch →

[C++11] STL: Coundition Variable - Прерывание потоков

[C++11] STL: Coundition Variable - Прерывание потоков

9.4K

In C++11, condition variables (std::condition_variable) enable efficient thread synchronization by allowing threads to block until a specific condition is met, preventing CPU waste from busy-waiting. When a thread calls wait() with a predicate, it releases the associated mutex and blocks until notified; notify() or notify_all() signals waiting threads to re-evaluate their predicates and potentially resume execution. This mechanism is essential for coordinating multiple threads where one thread waits for events (like user input) while others remain idle until signaled, making concurrent programs more efficient and responsive.

Click to watch →

Multithreading in Cpp [024] - std::condition_variable

Multithreading in Cpp [024] - std::condition_variable

2.2K

std::condition_variable in C++ provides an efficient mechanism for threads to wait until a specific condition becomes true, eliminating the performance overhead of busy-wait loops by allowing threads to sleep until notified. When a thread calls wait() on a condition variable, it atomically releases the associated mutex and blocks until another thread calls notify_one() or notify_all() to wake it. The notify_one() function wakes exactly one waiting thread, while notify_all() wakes all waiting threads. This approach is significantly more efficient than manually checking conditions in a loop because threads only consume CPU resources when they are actively waiting, rather than continuously polling a condition.

Click to watch →

Deep Dive

Exploring 'std::shared_mutex' (read-write locks) to allow concurrent read access while maintaining exclusive write access.

Пространства имен с++. namespace c++ что это. Изучение С++ для начинающих. Урок #125

Пространства имен с++. namespace c++ что это. Изучение С++ для начинающих. Урок #125

64.8K

The 'std' namespace contains all standard C++ library classes, functions, and objects. This namespace is automatically included in most C++ programs through headers like <iostream>, <vector>, and others. When developers use 'using namespace std;', they can access standard library components directly without prefixing them with 'std::'. This convention is widely adopted in the C++ community for standard library code, making it more convenient to work with built-in functionality.

Click to watch →

What is "using namespace std" and why is it considered a BAD PRACTICE? C++ Programming Questions

What is "using namespace std" and why is it considered a BAD PRACTICE? C++ Programming Questions

334.4K

The 'std' namespace stands for 'standard' and contains many commonly used objects like cout, endl, and string. Without explicitly referencing std, these objects are undefined. You can access them by writing std::cout, std::endl, or std::string, or by using the 'using' directive to bring specific objects into the current scope.

Click to watch →

23 फरवरी Biology Viral Questions | Class 12 Complete Bio |⚔️महा संग्राम⚔️| Most Important Exam 2026

23 फरवरी Biology Viral Questions | Class 12 Complete Bio |⚔️महा संग्राम⚔️| Most Important Exam 2026

133.4K

STD (Sexually Transmitted Disease) refers to diseases that spread through sexual contact from one person to another. Examples include AIDS, gonorrhea, and syphilis. These diseases can be transmitted through sexual intercourse, contaminated needles, or blood transfusion.

Click to watch →

Tajemnica Sandry została odkryta | Praktykanci #9 [4K]

Tajemnica Sandry została odkryta | Praktykanci #9 [4K]

141.8K

Sexually transmitted diseases (STDs) such as HIV, hepatitis B and C, gonorrhea, chlamydia, and herpes can be transmitted through oral sex, and individuals should get tested after three months of potential exposure; prevention methods include using condoms or dental dams, avoiding oral sex with mouth sores, and maintaining open communication with partners about sexual health.

Click to watch →

The pain they caused u has no comparison 2 what they about 2 go threw most high dnt play about u

The pain they caused u has no comparison 2 what they about 2 go threw most high dnt play about u

22.1K

The concept of STD and reconciliation suggests that someone who has been unfaithful or deceptive may want to come back, but they carry consequences that make reconciliation difficult. The concept of misfortune and loss suggests that those who have been harmful will face significant negative consequences. The concept of rumors and conversations going around suggests that the truth about a situation is becoming known to others. The concept of divorce and stress suggests that relationships are being affected by the exposure of hidden truths.

Click to watch →

Mutex Basics

Real-life Analogy

Code Problem

Lock Solution

Lock Guard

Unique Lock vs Guard

Mutex Basics

0:00

Playing Section

1
Defines mutex as mutual exclusion for thread safety.
2
Prevents simultaneous access to shared code.

66.3K views2K12:28@CodeBeautyOriginal Release: 2023-08-30

Mutex (Mutual Exclusion) is a synchronization mechanism in C++ that ensures only one thread can access a critical section of code at a time, preventing race conditions where multiple threads simultaneously access shared resources. The video demonstrates this using a car-sharing analogy where two friends cannot drive the same car simultaneously. Two implementation approaches are shown: lock_guard automatically locks and unlocks the mutex when the object goes out of scope, making it safer for simple cases, while unique_lock provides more flexibility by allowing manual unlock and deferred locking but requires careful management to avoid deadlocks.

[00:00:00]hi guys and welcome to my channel in this video I'm going to talk about one very interesting topic that confuses many beginners but it is very important to understand it and as you will see from this video it's not actually that hard uh so that is the topic of mutex and the first thing that I want to explain is what is mutex mutex is a term that is related to multi-threading in C plus plus and it stands for Mutual exclusion that means that mutex is a way to ensure that inside a multi-threaded application two threads cannot access the same code at the same time because that could cause many problems in your application in this video I will give you a short real life example of mutex so that you can understand the concept and if you want to learn more and if you want to understand more about multi-threading and how it's used in big projects and to build applications that we use every day then I would recommend you to watch my practical programming course the link will be in the description version and in that course multi-threading is just one of the many topics that you will learn because you will get all of the necessary skills so that you can start building applications yourself and get a job once you finish that course the course is going to be launched very soon and since you are my YouTube viewer I want to make sure that you get a special treatment when compared to other people so I'll put a link in the description that you can use to sign up and once the course is launched I am going to send you a special discount but as you will understand the number of people who can get this discount is limited so if you are interested it's completely free to sign up but do it right now so that you can secure your place so with that being said let's get back to the topic of new text as I said mutex is a way to prevent multiple threads from accessing the same part of the code at the same time and if you're not familiar with the concept of threads I already made another video where I explain multi-threading and the topic of threads and I will link that video here and also in the description so so make sure to watch it before you continue watching this video so what would be example of mutex in real life imagine the following situation let's say that you want to buy a Supercar and your friend also wants to buy a Supercar but you don't have enough money for example you have 1 million and he has 1 million but the car costs 2 million dollars so you decide to buy that car together and to share it but one thing that you need to keep in mind is that if you are sharing that car you cannot use it at the same time which means that if your friend is driving you will have to wait and if you are driving your friend will have to wait so those are the limitations now let's see how we can simulate that scenario in code so what I want to do is I want to create a function of return type void I will call it drive car okay and here I will receive one string parameter it will be string driver name okay and here I will simulate the driving of a car so I will say C out and then let's print driver's name and I will say here is driving okay and then I will say C out driver name and then let's say is done driving and let's put another end line and then here in between I will simulate the duration so the period while you are driving the car and I will do that by sleeping this thread so in order to do that you need to say include and then thread oh what is this include thread like this and now here I can say this thread okay and then let's say sleep four and here I will use Chrono okay and let's say seconds and I will say for example that you are driving for two seconds okay so this is our drive car function and now what I want to do is I want to simulate the situation where you and your friend are sharing the same car so how am I going to represent you and your friend well I am going to represent that with two threads so let's create thread if I say T1 and here I will pass two parameters the first one is going to be the method that this thread is executing and that is this drive car so what is going to be the task and the job of this thread and then the second thing is since this method receives one parameter I am going to pass it here and that is going to be the name of the driver so I will say saldina okay so this is the first friend the first thread and then let's create another one let's call it T2 its job is going to be the same function and the name of the driver will be let's say Elon okay so now these two threads are two friends that share the same card and now if I run this program we are going to see what will be the result of this application that we have written but one thing that we need to do first is the following I need to say T1 dot join and then also T2 dot join and this basically means before this program ends make sure that both of these threads have finished what they were doing so please don't end the program until both of these threads finish their job okay so you need to put this part here otherwise you are going to get an error so now let's see what's going to happen when we start the program okay Salina is driving Elon is driving and then Selena is done driving Elon is done driving I I a problem here and that is the following how can Elon drive the car before I finish driving the car so clearly we have a problem here where two threads or two friends are accessing the same resource at the same time which should not be possible what should happen instead is that I should drive the car and then once I finish driving the car then Elon can start driving and then when he finishes driving our application will end so now let's see how we can fix this problem so in order to solve this problem we use mutex and you can understand mutex as a lock that is used in order to lock certain part of the code while one thread is executing it and then once that thread finishes it will unlock that code so that other threads can access it and that part of the code that you want to lock is called critical section so in our case our critical section is this part of the code here so before one driver starts driving the car he will have to lock it here and then once he's done driving so that will be here he can unlock the car so that other drivers other threads can access that code so now let's see how we can write that code so the first thing that you need to do is you need to include mutex here okay and then you need to create a mutex that you will use in order to lock this critical section I will say new text and let's call it car mutex like this and then here I will lock my code so I will say unique lock of mutex I will call it car lock and do this variable I will give this mutex that we created okay so this is how we lock the critical section and then here once you are done driving what you need to do is you need to say car lock unlock okay so by simply doing and adding these two lines of code we have locked this critical section and now we shouldn't have the problem that we previously had so let's start the program and let's see the result okay saldina is driving and then saldina is not driving and only then Elon can start driving okay another thing that you should know is that there is a shorter way in order to lock this critical section so instead of using unique lock you can use lock guard how well it's actually very simple so you simply say lock guard like this the rest of the code stays the same and then here you can even delete this part where you are unlocking your critical section and we will come to that part and explain why in a moment but first I want to test the application let's see so saldina is driving and then seldina is not driving and only then Elon can start driving and then once he is done the application finishes okay so let's see what is the difference between lock guard and unique lock lock guard is easier and the more simple way to use mutex and its characteristics are following lock guard is going to lock your critical section at the same line where you create it also it is going to unlock the code automatically once this object goes out of scope and that is usually at the end of the block or at the end of the or at the end of the function so in our case that is here a disclosed curly bracket and because it is unlocking your code automatically that means that you cannot unlock it manually so lock guard cannot be unlocked manually that is the first thing and then the second thing which is benefit is that because it is unlocking the code and releasing mutex automatically it will make sure that your code is always unlocked and that the mutex is released properly even if your application has an exception or whatever happens your code is going to be properly unlocked and the mutex will be released so that is benefit so when you would use this lock guard you would use lock guard when you want to lock a short well-defined block of code like we have here on the other hand unique lock is harder to use but it has more options let's return this to Unique lock like this and here you will notice that I have unlocked my code manually and that is one thing that you have to do with unique lock so you need to unlock manually and if you forget to do that or if you don't know how to do it when to do it then you can cause huge problems in your application that is downside but it also has a benefit and that is that uni clock can be used in order to defer locking which means that you can delay locking because of different conditions and situations that happen in your application and also you can use the same object of unique lock in order to lock and unlock your code multiple times during the lifetime of this object which is something that you couldn't do with lock guard so as I promised at the beginning this video is going to be very easy to understand so I hope that now you do understand the idea and the concept of mutex in programming and if you want to learn more if you want to understand how this works in Big applications that you use every day and how you can build those applications as well then I invite you to sign up for my practical programming course the link will be in the description and it is completely free to sign up and in that course I'm going to teach you everything that you need to know in order to become a developer and start building the applications that you want to build and also since you are my YouTube viewer I will make sure to send you a special discount as soon as the course launches so that would be all for this video all of the code is going to be pinned in the comment and if you have any questions or any suggestions for my future videos leave those in the comment section as well and if you enjoyed this video and you have learned something new then definitely give it a thumbs up and say to the YouTube algorithm that you wanted to recommend you more videos like this where you can learn something new and where you can learn to code so thank you very much for watching and I will see you in some other video bye

Up Next

Thread Pool In C++: Efficient Multithreading Implementation Guide

@CppNuts

28.4K views•2024-02-27

BitTorrent Protocol Explained: Piece Selection & Peer Choking

@StevenGordonAU

481 views•2013-02-22

Introduction to Multithreading in Modern C++: Build Your First App

@CodeBeauty

230.4K views•2021-10-27

Enigma Machine Mechanics: WWII Encryption Explained

@JaredOwen

13.2M views•2021-12-11

Related Study Plans & Knowledge Roadmaps

Structured learning paths in Computer Science

View All Computer Science Topics

computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency

02Networking Foundations & P2P Architecture

03Bencode Parsing & Torrent Metadata

+ 3 more learning modules

Explore Roadmap

computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations

02Thread Pools and Task Scheduling

03Atomics and Lock-Free Queue Design

+ 3 more learning modules

Explore Roadmap

computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml

02Abstract Syntax Trees & Language Interpreters

03Type Systems & Lambda Calculus

+ 2 more learning modules

Explore Roadmap

computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations

02Authentication vs. Authorization & JWTs

03The OAuth 2.0 Protocol & Grant Types

+ 3 more learning modules

Explore Roadmap