C Spin Locks 🎯

Welcome to our deep dive into C Spin Locks! In this lesson, we'll explore the world of concurrent programming, where multiple tasks are executed at the same time, and learn how Spin Locks help manage these tasks effectively.

What are Spin Locks? 📝

Spin Locks are a simple synchronization primitive used in multithreaded programming to protect shared resources from simultaneous access. They achieve this by having a thread "spin" or wait (without giving up the CPU) until the shared resource becomes available.

Why do we need Spin Locks? 💡

When multiple threads try to access a shared resource, race conditions and deadlocks can occur, causing unpredictable behavior. Spin Locks help prevent these issues by ensuring only one thread accesses the shared resource at a time.

Understanding Spin Locks 🎯

A Spin Lock consists of two parts: a flag and a loop. The flag indicates whether the lock is free or occupied, and the loop keeps checking the flag until it becomes available.

The Spin Lock Code

#include <pthread.h>
#include <stdio.h>

pthread_spinlock_t lock;

void my_spin_lock_init() {
    pthread_spin_init(&lock, 0);
}

void my_spin_lock_acquire() {
    pthread_spin_lock(&lock);
}

void my_spin_lock_release() {
    pthread_spin_unlock(&lock);
}

In the above code, we first include the necessary header files. We then define a Spin Lock using pthread_spinlock_t. The functions my_spin_lock_init(), my_spin_lock_acquire(), and my_spin_lock_release() help initialize, acquire, and release the Spin Lock, respectively.

Practical Example 📝

Let's consider a simple scenario where two threads need to update a shared counter.

#include <pthread.h>
#include <stdio.h>

pthread_spinlock_t lock;
int counter = 0;

void increment(int id) {
    my_spin_lock_acquire();
    counter++;
    printf("Thread %d increased the counter to %d\n", id, counter);
    my_spin_lock_release();
}

void* worker(void* arg) {
    int id = (int)arg;
    for (int i = 0; i < 10; i++)
        increment(id);
    return NULL;
}

int main() {
    my_spin_lock_init();

    pthread_t threads[2];

    pthread_create(&threads[0], NULL, worker, (void*)1);
    pthread_create(&threads[1], NULL, worker, (void*)2);

    pthread_join(threads[0], NULL);
    pthread_join(threads[1], NULL);

    return 0;
}

In this example, we have two worker threads that increment a shared counter using the Spin Lock. When you run this code, you'll see the counter being updated by both threads concurrently, demonstrating the importance of using synchronization primitives like Spin Locks in multithreaded programming.

Happy coding! Let's continue learning and exploring the fascinating world of C programming together at CodeYourCraft. 🤝