• semaphores are used to limit the simultaneous execution of a code (procedure, line of code, etc.) to one or more threads at a given time. A semaphore can be shared between several applications.
• critical sections are used to limit the simultaneous execution of a code (procedure, line of code, etc.) to one thread at a given time in a single application.

1. Thread n°1 executes function MutexStart: no thread is currently present in the mutex.
2. Thread #1 runs the code section protected by the mutex.
3. While thread #1 executes the mutex-protected code, thread #2 executes the MutexStart function: as the mutex-protected code is already being executed by thread #1, thread #2 waits for the mutex to be released.
4. Thread n°1 executes function MutexEnd: no more threads execute the mutex code.
5. Thread #2 can run the code protected by the mutex.
6. Thread n°2 executes function MutexEnd: no more threads execute the mutex code.

Steps:

1. Creating a mutex with MutexCreate. The mutex is associated with a name.
2. Calling MutexStart before the code section to protect.
3. Calling MutexEnd to define the code section to protect. The lines of code after MutexEnd will no longer be protected.
4. Destroying the mutex with MutexDestroy.

Remarks

• The code sections protected by a mutex must be as short as possible and they must only affect the "critical" processes.
• When a thread is pending, the resources of the processor are not used.
• A mutex can be applied to the main thread and to the secondary threads (created by ThreadExecute). You must avoid locking the main thread. Indeed, if the main thread is locked (pending), the application cannot be run anymore.
• MutexStart and MutexEnd must be used in the same process (in a procedure for example).
• A mutex can be shared (or not) between the different applications run on the computer. When creating a mutex, specify how it will be shared (MutexCreate).

Functions for managing a mutex