Mutex Method Design Pattern

In embedded systems programming, a mutex (short for mutual exclusion) is often used to ensure that only one task or thread can access a shared resource at a time. This is crucial to prevent data corruption and other synchronization issues.

Let’s see an example:

C

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <pthread.h>
 
// Define a simple structure to represent the mutex
typedef struct {
    bool locked;
    pthread_mutex_t mutex;
} Mutex;
 
// Function to initialize the mutex
void initMutex(Mutex *mutex) {
    mutex->locked = false;
    pthread_mutex_init(&mutex->mutex, NULL);
}
 
// Function to acquire the mutex
void lockMutex(Mutex *mutex) {
    pthread_mutex_lock(&mutex->mutex);
    while (mutex->locked) {
        // If the mutex is already locked, wait until it becomes available
        pthread_mutex_unlock(&mutex->mutex);
        pthread_mutex_lock(&mutex->mutex);
    }
    // Mark the mutex as locked
    mutex->locked = true;
    pthread_mutex_unlock(&mutex->mutex);
}
 
// Function to release the mutex
void unlockMutex(Mutex *mutex) {
    pthread_mutex_lock(&mutex->mutex);
    // Mark the mutex as unlocked
    mutex->locked = false;
    pthread_mutex_unlock(&mutex->mutex);
}
 
// Example usage of the mutex
Mutex myMutex;
 
void* threadFunction(void* arg) {
    int threadID = *((int*)arg);
 
    lockMutex(&myMutex);
    printf("Thread %d has acquired the mutex.\n", threadID);
    // Critical section - Access the shared resource
    printf("Thread %d is in the critical section.\n", threadID);
    unlockMutex(&myMutex);
 
    pthread_exit(NULL);
}
 
int main() {
    initMutex(&myMutex);
 
    pthread_t thread1, thread2;
 
    int id1 = 1, id2 = 2;
 
    pthread_create(&thread1, NULL, threadFunction, (void*)&id1);
    pthread_create(&thread2, NULL, threadFunction, (void*)&id2);
 
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
 
    pthread_mutex_destroy(&myMutex.mutex);
 
    return 0;
}

Explanation of the above Code:

In this example,

A simple mutex using a binary semaphore. The lockMutex function is responsible for acquiring the mutex, and the unlockMutex function releases it.
The critical section between these two calls is protected, ensuring that only one thread can access it at a time.
The pthread library is used for thread management. Make sure to link your program with the pthread library when compiling (-lpthread flag).

Design Patterns for Embedded Systems in C

When working with embedded systems in C, there are so many design patterns that are particularly very useful. Many design patterns can be applied to embedded systems development in C. In this article, we will discuss design patterns for Embedded Systems in C, let’s see all of them one by one with the help of examples.

Important Topics for Design Patterns for Embedded Systems in C

What is a Design Pattern?
Creational Design Patterns for Embedded Systems in C
- Factory Method Design Pattern
- Object Method Design Pattern
- Opaque Method Design Pattern
- Singleton Method Design Pattern
Structural Design Patterns for Embedded Systems in C
- Callback Method Design Patterns
- Inheritance Method Design Pattern
- Virtual API Method Design Pattern
Other Design Patterns for Embedded System in C
- Bridge Method Design Pattern
- Concurrency Method Design Pattern
- Spinlock Method Design Pattern
- Mutex Method Design Pattern
- Conditional Method Design Pattern
- Behavioral Method Design Pattern

Mutex Method Design Pattern

C

Explanation of the above Code:

Design Patterns for Embedded Systems in C

Similar Reads

Contact Us