Advanced Threads & Concurrency

/*
 * 01-cli.c — CLI loading animation with a spinner thread
 *
 * Key concepts: Thread for UI animation, usleep for timing
 * Compile: gcc -o cli 01-cli.c -lpthread
 * Run:     ./prog
 */
// File: cli_loader_fetch.c
// Compile with: gcc -Wall -pthread cli_loader_fetch.c -o cli_loader_fetch

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include <signal.h>

// Shared flag to indicate when fetching is done
bool fetch_complete = false;

// Mutex to protect access to fetch_complete
pthread_mutex_t flag_mutex = PTHREAD_MUTEX_INITIALIZER;

// Loader thread function: displays a spinning loader
void* loader(void* arg) {
    const char spinner[] = "|/-\\";
    int idx = 0;

    while (1) {
        // Lock mutex to safely read fetch_complete
        pthread_mutex_lock(&flag_mutex);
        bool done = fetch_complete;
        pthread_mutex_unlock(&flag_mutex);

        if (done) {
            break;
        }

        // Display spinner
        printf("\rFetching data... %c", spinner[idx % 4]);
        fflush(stdout);
        idx++;
        usleep(100000); // 100 milliseconds
    }

    // Clear the spinner line after completion
    printf("\rFetching data... Done!      \n");
    pthread_exit(NULL);
}

// Worker thread function: simulates data fetching
void* fetch_data(void* arg) {
    // Simulate data fetching with sleep
    printf("[Worker] Starting data fetch (simulating 5 seconds)...\n");
    sleep(5);
    printf("[Worker] Data fetch completed!\n");

    // Lock mutex to safely update fetch_complete
    pthread_mutex_lock(&flag_mutex);
    fetch_complete = true;
    pthread_mutex_unlock(&flag_mutex);

    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  CLI loading animation with a spinner\n");
    printf("========================================\n\n");
    pthread_t loader_thread, worker_thread;
    int status;

    // Create the loader thread
    status = pthread_create(&loader_thread, NULL, loader, NULL);
    if (status != 0) {
        fprintf(stderr, "Error: Unable to create loader thread\n");
        exit(EXIT_FAILURE);
    }

    // Create the worker thread
    status = pthread_create(&worker_thread, NULL, fetch_data, NULL);
    if (status != 0) {
        fprintf(stderr, "Error: Unable to create worker thread\n");
        exit(EXIT_FAILURE);
    }

    // Wait for both threads to finish
    pthread_join(worker_thread, NULL);
    pthread_join(loader_thread, NULL);

    // Destroy the mutex
    pthread_mutex_destroy(&flag_mutex);

    printf("[Main] All tasks completed. The spinner ran while the worker fetched data.\n");
    return EXIT_SUCCESS;
}

/*
 * cli.c — Advanced CLI simulator with progress bars and spinners
 *
 * Key concepts: Multiple animation threads, terminal escape codes, ANSI colors
 * Compile: gcc -o cli2 cli.c -lpthread
 * Run:     ./prog
 */
// File: cli_loader_simulator.c
// Compile with: gcc -Wall -pthread cli_loader_simulator.c -o cli_loader_simulator

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include <signal.h>
#include <errno.h>
// Constants
#define MAX_FILES 5
#define PROGRESS_BAR_WIDTH 50

// ====================== Shared Resources ====================== //

// Structure to hold file loading information
typedef struct {
    char filename[100];
    int progress;          // Progress percentage (0-100)
    bool is_loading;       // Indicates if the file is currently loading
    bool is_loaded;        // Indicates if the file has finished loading
} FileLoad;

// Array to hold information about files being loaded
FileLoad files[MAX_FILES];
int num_files = 0;         // Number of files to load

// Mutex to protect access to the files array
pthread_mutex_t files_mutex = PTHREAD_MUTEX_INITIALIZER;

// Flag to indicate program termination
volatile sig_atomic_t terminate_program = 0;

// ====================== Function Prototypes ====================== //

void handle_sigint(int sig);
void display_menu();
void initialize_files();
void *file_loader(void *arg);
void update_display();

// ====================== Signal Handler ====================== //

/**
 * Handles SIGINT (Ctrl+C) to gracefully terminate the program.
 */
void handle_sigint(int sig) {
    terminate_program = 1;
}

// ====================== Helper Functions ====================== //

/**
 * Displays the main menu.
 */
void display_menu() {
    printf("\n========== Multithreaded File Loader ==========\n");
    printf("Commands:\n");
    printf("1. load   - Simulate loading multiple files\n");
    printf("2. status - Display loading progress\n");
    printf("3. exit   - Exit the program\n");
    printf("Enter command number: ");
    fflush(stdout);
}

/**
 * Initializes the files array with dummy filenames.
 */
void initialize_files() {
    pthread_mutex_lock(&files_mutex);
    num_files = MAX_FILES;
    for (int i = 0; i < MAX_FILES; i++) {
        snprintf(files[i].filename, sizeof(files[i].filename), "File_%d.txt", i + 1);
        files[i].progress = 0;
        files[i].is_loading = false;
        files[i].is_loaded = false;
    }
    pthread_mutex_unlock(&files_mutex);
}

/**
 * Generates a progress bar string based on the current progress.
 * @param progress The current progress percentage.
 * @return A string representing the progress bar.
 */
char* get_progress_bar(int progress) {
    static char bar[PROGRESS_BAR_WIDTH + 1];
    int pos = (progress * PROGRESS_BAR_WIDTH) / 100;
    for (int i = 0; i < PROGRESS_BAR_WIDTH; ++i) {
        if (i < pos)
            bar[i] = '#';
        else
            bar[i] = '-';
    }
    bar[PROGRESS_BAR_WIDTH] = '\0';
    return bar;
}

// ====================== Thread Function ====================== //

/**
 * Simulates loading a file by incrementing its progress.
 * @param arg Pointer to the file index in the files array.
 */
void *file_loader(void *arg) {
    int file_index = *((int *)arg);
    free(arg); // Free the allocated memory for argument

    pthread_mutex_lock(&files_mutex);
    files[file_index].is_loading = true;
    pthread_mutex_unlock(&files_mutex);

    while (1) {
        sleep(1); // Simulate time taken to load

        pthread_mutex_lock(&files_mutex);
        if (files[file_index].progress < 100) {
            files[file_index].progress += rand() % 20 + 1; // Increment progress by 1-20%
            if (files[file_index].progress > 100)
                files[file_index].progress = 100;
        }

        if (files[file_index].progress >= 100) {
            files[file_index].is_loading = false;
            files[file_index].is_loaded = true;
            pthread_mutex_unlock(&files_mutex);
            break;
        }
        pthread_mutex_unlock(&files_mutex);
    }

    pthread_exit(NULL);
}

// ====================== Display Function ====================== //

/**
 * Updates the CLI display with current progress of all files.
 */
void update_display() {
    pthread_mutex_lock(&files_mutex);
    printf("\033[H\033[J"); // Clear the screen using ANSI escape codes
    printf("========== File Loading Progress ==========\n");
    for (int i = 0; i < num_files; i++) {
        printf("%s: [%s] %d%%\n", files[i].filename, get_progress_bar(files[i].progress), files[i].progress);
    }
    printf("\nPress Ctrl+C to exit.\n");
    pthread_mutex_unlock(&files_mutex);
}

// ====================== Main Function ====================== //

int main() {
    // Seed random number generator
    srand(time(NULL));

    // Install signal handler for SIGINT
    signal(SIGINT, handle_sigint);

    // Initialize files
    initialize_files();

    // Clear the screen initially
    printf("\033[H\033[J");

    while (!terminate_program) {
        display_menu();

        char input[10];
        if (fgets(input, sizeof(input), stdin) == NULL) {
            if (errno == EINTR && terminate_program) {
                break;
            }
            continue;
        }

        // Remove newline character
        input[strcspn(input, "\n")] = '\0';

        switch (input[0]) {
            case '1':
            case 'l': // 'l' for 'load'
                // Check if files are already being loaded
                {
                    bool already_loading = false;
                    pthread_mutex_lock(&files_mutex);
                    for (int i = 0; i < num_files; i++) {
                        if (files[i].is_loading) {
                            already_loading = true;
                            break;
                        }
                    }
                    pthread_mutex_unlock(&files_mutex);

                    if (already_loading) {
                        printf("Files are already being loaded.\n");
                        break;
                    }

                    // Initialize files
                    initialize_files();

                    printf("Starting to load %d files...\n", num_files);

                    // Create threads to load files
                    for (int i = 0; i < num_files; i++) {
                        pthread_t thread;
                        int *arg = malloc(sizeof(*arg));
                        if (arg == NULL) {
                            fprintf(stderr, "Couldn't allocate memory for thread arg.\n");
                            exit(EXIT_FAILURE);
                        }
                        *arg = i;
                        int status = pthread_create(&thread, NULL, file_loader, arg);
                        if (status != 0) {
                            fprintf(stderr, "Error creating thread for %s\n", files[i].filename);
                            free(arg);
                        } else {
                            pthread_detach(thread); // Detach thread as we don't need to join
                        }
                    }

                    // Continuously update display until all files are loaded
                    while (1) {
                        update_display();

                        // Check if all files are loaded
                        bool all_loaded = true;
                        pthread_mutex_lock(&files_mutex);
                        for (int i = 0; i < num_files; i++) {
                            if (!files[i].is_loaded) {
                                all_loaded = false;
                                break;
                            }
                        }
                        pthread_mutex_unlock(&files_mutex);

                        if (all_loaded || terminate_program) {
                            break;
                        }

                        sleep(1); // Update every second
                    }

                    if (terminate_program) {
                        break;
                    }

                    printf("\nAll files have been loaded successfully!\n");
                }
                break;

            case '2':
            case 's': // 's' for 'status'
                update_display();
                break;

            case '3':
            case 'e': // 'e' for 'exit'
                printf("Exiting program...\n");
                terminate_program = 1;
                break;

            default:
                printf("Unknown command. Please try again.\n");
                break;
        }
    }

    // Cleanup: Ensure all loading threads are terminated
    pthread_mutex_lock(&files_mutex);
    for (int i = 0; i < num_files; i++) {
        // In this simulation, threads will finish naturally.
        // If threads were blocking on conditions, you would signal them here.
    }
    pthread_mutex_unlock(&files_mutex);

    // Destroy the mutex
    pthread_mutex_destroy(&files_mutex);

    printf("Program terminated gracefully.\n");
    return EXIT_SUCCESS;
}

/*
 * 03-forks-mutex.c — Fork + semaphore — file-based synchronization across processes
 *
 * Key concepts: Named semaphore with forked processes, sem_open, sem_wait, sem_post
 * Compile: gcc -o fork_sem 03-forks-mutex.c -lpthread
 * Run:     ./prog
 */
// File: synchronized_file_write.c
// Compile with: gcc -Wall -o synchronized_file_write synchronized_file_write.c -lrt

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>    // For O_CREAT, O_RDWR
#include <sys/stat.h> // For mode constants
#include <semaphore.h>
#include <sys/wait.h>
#include <string.h>
#include <errno.h>

#define NUM_PROCESSES 5
#define SEM_NAME "/my_named_semaphore"
#define FILE_NAME "shared_output.txt"

int main()
{
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Fork + Semaphore — File Sync\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Parent] %d child processes will write to '%s' protected by semaphore.\n\n", NUM_PROCESSES, FILE_NAME);
    pid_t pid;
    sem_t *mutex;

    // Remove any existing semaphore with the same name to prevent conflicts
    // good practice not mandatory
    int status = sem_unlink(SEM_NAME);
    if (status == -1)
    {
        if (errno != ENOENT)
        { // ENOENT: No such file or directory to if it isnt, then error
            perror("sem_unlink failed");
            exit(EXIT_FAILURE);
        }
    }

    // Create and initialize the named semaphore to 1 (binary semaphore)
    mutex = sem_open(SEM_NAME, O_CREAT, 0600, 1);
    if (mutex == SEM_FAILED)
    {
        perror("sem_open failed");
        exit(EXIT_FAILURE);
    }

    // Create the shared file or truncate if it exists to ensure a clean start
    FILE *fp = fopen(FILE_NAME, "w");
    if (fp == NULL)
    {
        perror("fopen failed");
        sem_close(mutex);
        sem_unlink(SEM_NAME);
        exit(EXIT_FAILURE);
    }
    fclose(fp);

    // Spawn child processes
    for (int i = 0; i < NUM_PROCESSES; i++)
    {
        pid = fork();
        if (pid < 0)
        {
            perror("fork failed");
            // Cleanup before exiting
            sem_close(mutex);
            sem_unlink(SEM_NAME);
            exit(EXIT_FAILURE);
        }
        else if (pid == 0)
        {
            // Child process

            // Open the named semaphore
            sem_t *child_mutex = sem_open(SEM_NAME, 0);
            if (child_mutex == SEM_FAILED)
            {
                perror("Child sem_open failed");
                exit(EXIT_FAILURE);
            }

            // Wait (lock) the semaphore before entering the critical section
            if (sem_wait(child_mutex) == -1)
            {
                perror("sem_wait failed");
                sem_close(child_mutex);
                exit(EXIT_FAILURE);
            }

            // Critical section: write to the shared file
            FILE *child_fp = fopen(FILE_NAME, "a");
            if (child_fp == NULL)
            {
                perror("Child fopen failed");
                sem_post(child_mutex);
                sem_close(child_mutex);
                exit(EXIT_FAILURE);
            }

            // Create a unique message for each child
            char message[100];
            snprintf(message, sizeof(message), "Process %d (PID %d) is writing this line.\n", i + 1, getpid());
            fprintf(child_fp, "%s", message);
            printf("[Child %d, PID %d] Acquired semaphore → wrote to file → releasing.\n", i + 1, getpid());

            fclose(child_fp);

            // Post (unlock) the semaphore after exiting the critical section
            if (sem_post(child_mutex) == -1)
            {
                perror("sem_post failed");
                sem_close(child_mutex);
                exit(EXIT_FAILURE);
            }

            // Close the semaphore in the child process
            sem_close(child_mutex);
            exit(EXIT_SUCCESS);
        }
    }

    // Parent process waits for all child processes to complete
    for (int i = 0; i < NUM_PROCESSES; i++)
    {
        wait(NULL);
    }

    // Clean up: close and unlink the semaphore
    sem_close(mutex);
    sem_unlink(SEM_NAME);

    printf("\n[Parent] All children finished. Check output: cat %s\n", FILE_NAME);
    return EXIT_SUCCESS;
}

/*
 * 04-forks-mutex.c — IPC producer-consumer with shared memory and semaphores
 *
 * Key concepts: shmget + named semaphores, cross-process synchronization
 * Compile: gcc -o ipc_prodcons 04-forks-mutex.c -lpthread
 * Run:     ./prog
 */
// File: ipc_producer_consumer.c
// Compile with: gcc -Wall -o ipc_producer_consumer ipc_producer_consumer.c -lrt

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
#include <fcntl.h>    // For O_CREAT, O_RDWR
#include <sys/stat.h> // For mode constants
#include <sys/wait.h>

#include <sys/ipc.h>
#include <string.h>
#include <errno.h>
#include <sys/shm.h>
#define BUFFER_SIZE 5
#define NUM_PRODUCERS 2
#define NUM_CONSUMERS 2
#define ITEMS_PER_PRODUCER 10

// Semaphore names
#define SEM_MUTEX_NAME "/sem_mutex_ipc"
#define SEM_EMPTY_NAME "/sem_empty_ipc"
#define SEM_FULL_NAME "/sem_full_ipc"

// Shared memory key
#define SHM_KEY_PATH "/tmp"
#define SHM_KEY_ID 'y'

// Structure for shared buffer
typedef struct
{
    int buffer[BUFFER_SIZE];
    int in;
    int out;
} shared_buffer_t;

// Function prototypes
void producer(int producer_id, shared_buffer_t *shared_buffer, sem_t *mutex, sem_t *empty, sem_t *full);
void consumer(int consumer_id, shared_buffer_t *shared_buffer, sem_t *mutex, sem_t *empty, sem_t *full);

// global variables
sem_t *mutex, *empty, *full;
shared_buffer_t *shared_buffer;

void unlinker(int amount)
{
    for (int i = 0; i < amount; i++)
    {
        sem_unlink(SEM_MUTEX_NAME);
        sem_unlink(SEM_EMPTY_NAME);
        sem_unlink(SEM_FULL_NAME);
    }
}
void closer(sem_t **sem, int amount)
{
    for (int i = 0; i < amount; i++)
    {
        sem_close(sem[i]);
    }
}
void closeAll()
{
    sem_t *sems[] = {mutex, empty, full};
    closer(sems, 3);
    unlinker(3);
}
int main()
{
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  IPC Producer-Consumer (Shared Memory)\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Parent] %d producers, %d consumers, buffer size %d, %d items each.\n", NUM_PRODUCERS, NUM_CONSUMERS, BUFFER_SIZE, ITEMS_PER_PRODUCER);
    printf("[Parent] Uses fork + shared memory + named semaphores.\n\n");
    pid_t pid;

    key_t shm_key;
    int shm_id;

    // Remove existing semaphores and shared memory if any
    unlinker(3);

    // Create named semaphores
    mutex = sem_open(SEM_MUTEX_NAME, O_CREAT, 0600, 1); // Binary semaphore for mutual exclusion
    if (mutex == SEM_FAILED)
    {
        perror("sem_open failed for mutex");
        exit(EXIT_FAILURE);
    }

    empty = sem_open(SEM_EMPTY_NAME, O_CREAT, 0600, BUFFER_SIZE); // Counting semaphore for empty slots
    if (empty == SEM_FAILED)
    {
        perror("sem_open failed for empty");
        sem_close(mutex);
        closer(&mutex, 1);
        unlinker(1);
        exit(EXIT_FAILURE);
    }

    full = sem_open(SEM_FULL_NAME, O_CREAT, 0600, 0); // Counting semaphore for full slots
    if (full == SEM_FAILED)
    {
        perror("sem_open failed for full");
        sem_t *sems[] = {mutex, empty};
        closer(sems, 2);

        unlinker(2);
        exit(EXIT_FAILURE);
    }

    // Generate unique key for shared memory
    shm_key = ftok(SHM_KEY_PATH, SHM_KEY_ID);
    if (shm_key == -1)
    {
        closeAll();
        exit(EXIT_FAILURE);
    }

    // Create shared memory segment
    shm_id = shmget(shm_key, sizeof(shared_buffer_t), IPC_CREAT | 0600);
    if (shm_id == -1)
    {
        perror("shmget failed");
        closeAll();
        exit(EXIT_FAILURE);
    }

    // Attach shared memory segment
    shared_buffer = (shared_buffer_t *)shmat(shm_id, NULL, 0);
    if (shared_buffer == (void *)-1)
    {
        perror("shmat failed");
        shmctl(shm_id, IPC_RMID, NULL);
        closeAll();
        exit(EXIT_FAILURE);
    }

    // Initialize shared buffer
    shared_buffer->in = 0;
    shared_buffer->out = 0;
    memset(shared_buffer->buffer, 0, sizeof(shared_buffer->buffer));

    // Spawn producer processes
    for (int i = 0; i < NUM_PRODUCERS; i++)
    {
        pid = fork();
        if (pid < 0)
        {
            perror("fork failed for producer");
            // Cleanup before exiting
            shmdt(shared_buffer);
            shmctl(shm_id, IPC_RMID, NULL);
            closeAll();
            exit(EXIT_FAILURE);
        }
        else if (pid == 0)
        {
            // Child process - Producer
            producer(i + 1, shared_buffer, mutex, empty, full);
            // Detach shared memory and exit
            shmdt(shared_buffer);
            exit(EXIT_SUCCESS);
        }
    }

    // Spawn consumer processes
    for (int i = 0; i < NUM_CONSUMERS; i++)
    {
        pid = fork();
        if (pid < 0)
        {
            perror("fork failed for consumer");
            // Cleanup before exiting
            shmdt(shared_buffer);
            shmctl(shm_id, IPC_RMID, NULL);
            closeAll();
            exit(EXIT_FAILURE);
        }
        else if (pid == 0)
        {
            // Child process - Consumer
            consumer(i + 1, shared_buffer, mutex, empty, full);
            // Detach shared memory and exit
            shmdt(shared_buffer);
            exit(EXIT_SUCCESS);
        }
    }

    // Parent process waits for all children to finish
    for (int i = 0; i < NUM_PRODUCERS + NUM_CONSUMERS; i++)
    {
        wait(NULL);
    }

    // Detach and remove shared memory
    shmdt(shared_buffer);
    shmctl(shm_id, IPC_RMID, NULL);

    // Clean up semaphores
    closeAll();
    printf("\n[Parent] All producers and consumers finished. Shared memory released.\n");
    return EXIT_SUCCESS;
}

void producer(int producer_id, shared_buffer_t *shared_buffer, sem_t *mutex, sem_t *empty, sem_t *full)
{
    srand(getpid()); // Seed the random number generator

    for (int i = 0; i < ITEMS_PER_PRODUCER; i++)
    {
        int item = producer_id * 100 + i; // Unique item

        // Wait (lock) on 'empty' semaphore to ensure there's space
        if (sem_wait(empty) == -1)
        {
            perror("sem_wait failed on empty");
            exit(EXIT_FAILURE);
        }

        // Lock the mutex before accessing the buffer
        if (sem_wait(mutex) == -1)
        {
            perror("sem_wait failed on mutex");
            sem_post(empty); // Release 'empty' if mutex lock fails
            exit(EXIT_FAILURE);
        }

        // Critical section: Add item to buffer
        shared_buffer->buffer[shared_buffer->in] = item;
        printf("[Producer %d] Produced item %d → buffer[%d]\n", producer_id, item, shared_buffer->in);
        shared_buffer->in = (shared_buffer->in + 1) % BUFFER_SIZE;

        // Unlock the mutex after accessing the buffer
        if (sem_post(mutex) == -1)
        {
            perror("sem_post failed on mutex");
            exit(EXIT_FAILURE);
        }

        // Signal that buffer has at least one full slot
        if (sem_post(full) == -1)
        {
            perror("sem_post failed on full");
            exit(EXIT_FAILURE);
        }

        // Simulate production time
        usleep(100000); // 100 ms
    }

    printf("[Producer %d] Finished — produced %d items.\n", producer_id, ITEMS_PER_PRODUCER);
}

void consumer(int consumer_id, shared_buffer_t *shared_buffer, sem_t *mutex, sem_t *empty, sem_t *full)
{
    for (int i = 0; i < ITEMS_PER_PRODUCER; i++)
    {
        // Wait (lock) on 'full' semaphore to ensure there's at least one item
        if (sem_wait(full) == -1)
        {
            perror("sem_wait failed on full");
            exit(EXIT_FAILURE);
        }

        // Lock the mutex before accessing the buffer
        if (sem_wait(mutex) == -1)
        {
            perror("sem_wait failed on mutex");
            sem_post(full); // Release 'full' if mutex lock fails
            exit(EXIT_FAILURE);
        }

        // Critical section: Remove item from buffer
        int item = shared_buffer->buffer[shared_buffer->out];
        if (item == -1)
        { // Poison pill to signal termination (optional)
            // Unlock the mutex and 'full' semaphore before exiting
            if (sem_post(mutex) == -1)
            {
                perror("sem_post failed on mutex during termination");
                exit(EXIT_FAILURE);
            }
            if (sem_post(full) == -1)
            {
                perror("sem_post failed on full during termination");
                exit(EXIT_FAILURE);
            }
            break;
        }
        printf("[Consumer %d] Consumed item %d ← buffer[%d]\n", consumer_id, item, shared_buffer->out);
        shared_buffer->out = (shared_buffer->out + 1) % BUFFER_SIZE;

        // Unlock the mutex after accessing the buffer
        if (sem_post(mutex) == -1)
        {
            perror("sem_post failed on mutex");
            exit(EXIT_FAILURE);
        }

        // Signal that buffer has at least one empty slot
        if (sem_post(empty) == -1)
        {
            perror("sem_post failed on empty");
            exit(EXIT_FAILURE);
        }

        // Simulate consumption time
        usleep(150000); // 150 ms
    }

    printf("[Consumer %d] Finished — consumed %d items.\n", consumer_id, ITEMS_PER_PRODUCER);
}

/*
 * 05-forks-philosph.c — Dining Philosophers problem — classic deadlock scenario
 *
 * Key concepts: Named semaphores, shared memory, fork(), deadlock prevention
 *               via resource ordering (lowest-numbered fork first)
 * Compile: gcc -o philosophers 05-forks-philosph.c -lpthread -lrt
 * Run:     ./philosophers
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
#include <fcntl.h>           // For O_CREAT, O_RDWR
#include <sys/stat.h>        // For mode constants
#include <sys/wait.h>
#include <sys/shm.h>      // For shmget, shmat
#include <sys/ipc.h>
#include <string.h>
#include <errno.h>
#include <time.h>

#define NUM_PHILOSOPHERS 5
#define EAT_COUNT 3

// Semaphore names for forks
const char *fork_names[NUM_PHILOSOPHERS] = {
    "/fork0_ipc",
    "/fork1_ipc",
    "/fork2_ipc",
    "/fork3_ipc",
    "/fork4_ipc"
};

// Shared memory key
#define SHM_KEY_PATH "/tmp"
#define SHM_KEY_ID 'z'

// Structure for dining status (optional)
typedef struct {
    int times_eaten[NUM_PHILOSOPHERS];
} dining_status_t;

// Function prototypes
void philosopher(int phil_id, sem_t **forks, dining_status_t *status);
void cleanup_semaphores();
void cleanup_shared_memory();

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Dining Philosophers Problem\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Main] Classic deadlock scenario solved with resource ordering.\n");
    printf("[Main] Each philosopher picks up the lower-numbered fork first.\n\n");
    pid_t pid;
    sem_t *forks[NUM_PHILOSOPHERS];
    key_t shm_key;
    int shm_id;
    dining_status_t *dining_status;

    // Remove existing semaphores and shared memory if any
    for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
        sem_unlink(fork_names[i]);
    }
    // Note: using System V shared memory (shmget), not POSIX (shm_open)

    // Initialize semaphores for forks
    for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
        forks[i] = sem_open(fork_names[i], O_CREAT, 0600, 1); // Each fork is a binary semaphore
        if (forks[i] == SEM_FAILED) {
            perror("sem_open failed for fork");
            // Cleanup any already opened semaphores
            for (int j = 0; j < i; j++) {
                sem_close(forks[j]);
                sem_unlink(fork_names[j]);
            }
            exit(EXIT_FAILURE);
        }
    }

    // Generate unique key for shared memory
    shm_key = ftok(SHM_KEY_PATH, SHM_KEY_ID);
    if (shm_key == -1) {
        perror("ftok failed");
        cleanup_semaphores();
        exit(EXIT_FAILURE);
    }

    // Create shared memory segment
    shm_id = shmget(shm_key, sizeof(dining_status_t), IPC_CREAT | 0600);
    if (shm_id == -1) {
        perror("shmget failed");
        cleanup_semaphores();
        exit(EXIT_FAILURE);
    }

    // Attach shared memory segment
    dining_status = (dining_status_t *)shmat(shm_id, NULL, 0);
    if (dining_status == (void *)-1) {
        perror("shmat failed");
        shmctl(shm_id, IPC_RMID, NULL);
        cleanup_semaphores();
        exit(EXIT_FAILURE);
    }

    // Initialize dining status
    for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
        dining_status->times_eaten[i] = 0;
    }

    // Seed the random number generator
    srand(time(NULL));

    // Create philosopher processes
    for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
        pid = fork();
        if (pid < 0) {
            perror("fork failed for philosopher");
            // Cleanup before exiting
            shmdt(dining_status);
            shmctl(shm_id, IPC_RMID, NULL);
            cleanup_semaphores();
            exit(EXIT_FAILURE);
        } else if (pid == 0) {
            // Child process - Philosopher
            philosopher(i, forks, dining_status);
            // Detach shared memory and exit
            shmdt(dining_status);
            exit(EXIT_SUCCESS);
        }
    }

    // Parent process waits for all philosopher processes to finish
    for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
        wait(NULL);
    }

    // Display dining status
    printf("\n--- Dining Status (from shared memory) ---\n");
    for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
        printf("  Philosopher %d: ate %d times\n", i, dining_status->times_eaten[i]);
    }

    // Cleanup
    shmdt(dining_status);
    shmctl(shm_id, IPC_RMID, NULL);
    cleanup_semaphores();

    printf("\n--- Dining Philosophers simulation completed (no deadlocks!) ---\n");
    return EXIT_SUCCESS;
}

void philosopher(int phil_id, sem_t **forks, dining_status_t *status) {
    int left = phil_id;
    int right = (phil_id + 1) % NUM_PHILOSOPHERS;

    // To prevent deadlock, enforce resource ordering by always picking up the lower-numbered fork first
    int first = left < right ? left : right;
    int second = left < right ? right : left;

    for (int i = 0; i < EAT_COUNT; i++) {
        // Thinking
        printf("[Philosopher %d] 💭 Thinking... (round %d/%d)\n", phil_id, i + 1, EAT_COUNT);
        usleep((rand() % 500 + 500) * 1000); // 0.5 to 1 second

        // Picking up first fork
        printf("[Philosopher %d] Hungry! Reaching for fork %d (lower-numbered first to prevent deadlock)\n", phil_id, first);
        if (sem_wait(forks[first]) == -1) {
            perror("sem_wait failed on first fork");
            exit(EXIT_FAILURE);
        }
        printf("[Philosopher %d] ✓ Got fork %d. Now reaching for fork %d...\n", phil_id, first, second);
        if (sem_wait(forks[second]) == -1) {
            perror("sem_wait failed on second fork");
            // Release the first fork before exiting
            sem_post(forks[first]);
            exit(EXIT_FAILURE);
        }
        printf("[Philosopher %d] ✓ Got fork %d. 🍝 EATING!\n", phil_id, second);
        usleep((rand() % 500 + 500) * 1000); // 0.5 to 1 second
        status->times_eaten[phil_id]++;

        // Putting down second fork
        if (sem_post(forks[second]) == -1) {
            perror("sem_post failed on second fork");
            exit(EXIT_FAILURE);
        }
        printf("[Philosopher %d] Put down fork %d\n", phil_id, second);

        // Putting down first fork
        if (sem_post(forks[first]) == -1) {
            perror("sem_post failed on first fork");
            exit(EXIT_FAILURE);
        }
        printf("[Philosopher %d] Put down fork %d — done eating.\n", phil_id, first);
    }

    printf("[Philosopher %d] Finished! Ate %d times total.\n", phil_id, EAT_COUNT);
}

void cleanup_semaphores() {
    // Close and unlink all fork semaphores
    for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
        sem_close(sem_open(fork_names[i], 0));
        sem_unlink(fork_names[i]);
    }
}

/*
 * 07-pthreads-2.c — Thread logging — ordered output with mutex
 *
 * Key concepts: Mutex-protected printf, consistent log output
 * Compile: gcc -o logging 07-pthreads-2.c -lpthread
 * Run:     ./prog
 */
// File: thread_safe_logging.c
// Compile with: gcc -Wall -pthread -o thread_safe_logging thread_safe_logging.c

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

#define NUM_THREADS 5
#define LOG_ENTRIES_PER_THREAD 1000
#define LOG_FILE "thread_log.txt"

// Mutex to protect file writing
pthread_mutex_t file_mutex;

void* write_log(void* arg) {
    long thread_id = (long)arg;
    FILE *fp;

    for (int i = 0; i < LOG_ENTRIES_PER_THREAD; i++) {
        // Lock the mutex before writing to the file
        pthread_mutex_lock(&file_mutex);
        
        // Critical section: write to the log file
        fp = fopen(LOG_FILE, "a");
        if (fp == NULL) {
            perror("fopen failed");
            pthread_mutex_unlock(&file_mutex);
            pthread_exit(NULL);
        }

        fprintf(fp, "Thread %ld: Log entry %d\n", thread_id, i + 1);
        fclose(fp);
        
        // Unlock the mutex after writing
        pthread_mutex_unlock(&file_mutex);
    }
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Thread-Safe File Logging\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Main] %d threads each write %d log entries to %s.\n", NUM_THREADS, LOG_ENTRIES_PER_THREAD, LOG_FILE);
    printf("[Main] Mutex ensures log lines don't get interleaved.\n\n");
    pthread_t threads[NUM_THREADS];
    int rc;

    // Initialize the mutex
    if (pthread_mutex_init(&file_mutex, NULL) != 0) {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }

    // Create or truncate the log file
    FILE *fp = fopen(LOG_FILE, "w");
    if (fp == NULL) {
        perror("Initial fopen failed");
        pthread_mutex_destroy(&file_mutex);
        exit(EXIT_FAILURE);
    }
    fclose(fp);

    // Create threads
    for (long t = 0; t < NUM_THREADS; t++) {
        rc = pthread_create(&threads[t], NULL, write_log, (void*)t);
        if (rc) {
            fprintf(stderr, "Error: Unable to create thread %ld, return code %d\n", t, rc);
            pthread_mutex_destroy(&file_mutex);
            exit(EXIT_FAILURE);
        }
    }

    // Wait for all threads to finish
    for (int t = 0; t < NUM_THREADS; t++) {
        pthread_join(threads[t], NULL);
    }

    // Destroy the mutex
    pthread_mutex_destroy(&file_mutex);

    int total = NUM_THREADS * LOG_ENTRIES_PER_THREAD;
    printf("[Main] All threads finished. %d log entries written to %s.\n", total, LOG_FILE);
    printf("[Main] Check with: wc -l %s (should be %d)\n", LOG_FILE, total);
    return 0;
}

/*
 * 08-cool-bank.c — Bank simulation — concurrent account transfers
 *
 * Key concepts: Multiple threads transferring money, mutex per account, avoiding deadlock
 * Compile: gcc -o bank 08-cool-bank.c -lpthread
 * Run:     ./prog
 */
// File: thread_safe_bank.c
// Compile with: gcc -Wall -pthread -o thread_safe_bank thread_safe_bank.c

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

#define NUM_THREADS 6
#define OPERATIONS_PER_THREAD 1000

// Shared bank account balance
long long account_balance = 0;

// Mutex to protect the account balance
pthread_mutex_t account_mutex;

// Function for deposit operations
void* deposit(void* arg) {
    for(int i = 0; i < OPERATIONS_PER_THREAD; i++) {
        // Lock the mutex before modifying the balance
        pthread_mutex_lock(&account_mutex);
        
        // Critical section: Deposit $1
        account_balance += 1;
        // (not printing per-operation to avoid flooding output with 1000 lines)
        // Unlock the mutex after modification
        pthread_mutex_unlock(&account_mutex);
    }
    printf("[Deposit Thread] Finished — deposited $%d total\n", OPERATIONS_PER_THREAD);
    pthread_exit(NULL);
}

// Function for withdrawal operations
void* withdraw(void* arg) {
    for(int i = 0; i < OPERATIONS_PER_THREAD; i++) {
        // Lock the mutex before modifying the balance
        pthread_mutex_lock(&account_mutex);
        
        // Critical section: Withdraw $1 if possible
        
            account_balance -= 1;
       
        // (not printing per-operation to avoid flooding output)
        // Unlock the mutex after modification
        pthread_mutex_unlock(&account_mutex);
    }
    printf("[Withdraw Thread] Finished — withdrew $%d total\n", OPERATIONS_PER_THREAD);
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Bank Simulation — Concurrent Transfers\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Main] %d threads: %d deposit, %d withdraw. Each does %d operations ($1 each).\n", NUM_THREADS, NUM_THREADS/2, NUM_THREADS/2, OPERATIONS_PER_THREAD);
    printf("[Main] With mutex: balance should end at $0 (deposits == withdrawals).\n\n");
    pthread_t threads[NUM_THREADS];
    int rc;

    // Initialize the mutex
    if(pthread_mutex_init(&account_mutex, NULL) != 0) {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }

    // Create threads: half will deposit, half will withdraw
    for(long t = 0; t < NUM_THREADS; t++) {
        if(t % 2 == 0) {
            rc = pthread_create(&threads[t], NULL, deposit, NULL);
        } else {
            rc = pthread_create(&threads[t], NULL, withdraw, NULL);
        }
        if(rc) {
            fprintf(stderr, "Error: Unable to create thread %ld, return code %d\n", t, rc);
            exit(EXIT_FAILURE);
        }
    }

    // Wait for all threads to finish
    for(int t = 0; t < NUM_THREADS; t++) {
        pthread_join(threads[t], NULL);
    }

    // Destroy the mutex
    pthread_mutex_destroy(&account_mutex);

    long long expected = 0; // equal deposits and withdrawals
    printf("\n══════════════════════════════════════\n");
    printf("  Final balance: $%lld (expected: $%lld) %s\n", account_balance, expected, account_balance == expected ? "✓" : "← BUG!");
    printf("══════════════════════════════════════\n");
    return 0;
}

/*
 * 09-cool-canvas.c — Shared canvas — threads drawing on a 2D grid
 *
 * Key concepts: Mutex-protected 2D array, concurrent writes, terminal visualization
 * Compile: gcc -o canvas 09-cool-canvas.c -lpthread
 * Run:     ./prog
 */
// File: multithreaded_drawing_with_display.c
// Compile with: gcc -Wall -pthread -o multithreaded_drawing_with_display multithreaded_drawing_with_display.c

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

// Canvas dimensions
#define CANVAS_WIDTH 20
#define CANVAS_HEIGHT 10

// Number of drawing threads
#define NUM_DRAWING_THREADS 5

// Number of rectangles each thread will draw
#define RECTANGLES_PER_THREAD 10

// Display refresh interval in microseconds (e.g., 500000 for 0.5 seconds)
#define DISPLAY_INTERVAL 500000

// Structure representing the canvas
typedef struct {
    int width;
    int height;
    char **grid;
} canvas_t;

// Shared canvas
canvas_t canvas;

// Mutex to protect the canvas
pthread_mutex_t canvas_mutex;

// Flag to indicate when drawing is complete
int drawing_complete = 0;

// Function to initialize the canvas
void initialize_canvas(canvas_t *c, int width, int height) {
    c->width = width;
    c->height = height;
    c->grid = malloc(height * sizeof(char*));
    if (c->grid == NULL) {
        perror("Failed to allocate memory for canvas rows");
        exit(EXIT_FAILURE);
    }
    for(int i = 0; i < height; i++) {
        c->grid[i] = malloc(width * sizeof(char));
        if (c->grid[i] == NULL) {
            perror("Failed to allocate memory for canvas columns");
            // Free previously allocated rows before exiting
            for(int j = 0; j < i; j++) {
                free(c->grid[j]);
            }
            free(c->grid);
            exit(EXIT_FAILURE);
        }
        for(int j = 0; j < width; j++) {
            c->grid[i][j] = '.'; // Initialize canvas with dots
        }
    }
}

// Function to free the canvas
void free_canvas(canvas_t *c) {
    for(int i = 0; i < c->height; i++) {
        free(c->grid[i]);
    }
    free(c->grid);
}

// Function to print the canvas
void print_canvas(canvas_t *c) {
    // Clear the terminal screen (works on UNIX-like systems)
    printf("\033[H\033[J");
    for(int i = 0; i < c->height; i++) {
        for(int j = 0; j < c->width; j++) {
            printf("%c ", c->grid[i][j]);
        }
        printf("\n");
    }
}

// Function for drawing threads
void* draw_rectangles(void* arg) {
    long thread_id = (long)arg;
    char thread_char = 'A' + thread_id; // Unique character for each thread

    srand(time(NULL) + thread_id); // Seed randomness differently for each thread

    for(int i = 0; i < RECTANGLES_PER_THREAD; i++) {
        // Generate random rectangle dimensions and position
        int rect_width = rand() % 3 + 2;    // Width between 2 and 4
        int rect_height = rand() % 3 + 2;   // Height between 2 and 4
        int pos_x = rand() % (canvas.width - rect_width + 1);
        int pos_y = rand() % (canvas.height - rect_height + 1);

        // Lock the mutex before modifying the canvas
        pthread_mutex_lock(&canvas_mutex);

        // Draw the rectangle on the canvas
        for(int y = pos_y; y < pos_y + rect_height; y++) {
            for(int x = pos_x; x < pos_x + rect_width; x++) {
                canvas.grid[y][x] = thread_char; // Represent each thread with a unique letter
            }
        }
       // printf("Thread %ld drew a rectangle at (%d, %d) of size %dx%d.\n", thread_id, pos_x, pos_y, rect_width, rect_height);

        // Unlock the mutex after modification
        pthread_mutex_unlock(&canvas_mutex);

        // Simulate time taken to draw
        usleep(1000000); // 1000 ms
    }

    pthread_exit(NULL);
}

// Function for the display thread
void* display_canvas(void* arg) {
    while(1) {
        // Lock the mutex before reading the canvas
        pthread_mutex_lock(&canvas_mutex);

        // Print the current state of the canvas
        print_canvas(&canvas);

        // Check if drawing is complete
        if(drawing_complete) {
            pthread_mutex_unlock(&canvas_mutex);
            break;
        }

        // Unlock the mutex after reading
        pthread_mutex_unlock(&canvas_mutex);

        // Sleep for the defined interval before refreshing
        usleep(DISPLAY_INTERVAL);
    }
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Shared Canvas — Concurrent Drawing\n");
    printf("══════════════════════════════════════\n\n");
    pthread_t drawing_threads[NUM_DRAWING_THREADS];
    pthread_t display_thread;
    int rc;

    // Initialize the canvas
    initialize_canvas(&canvas, CANVAS_WIDTH, CANVAS_HEIGHT);

    // Initialize the mutex
    if(pthread_mutex_init(&canvas_mutex, NULL) != 0) {
        perror("Mutex initialization failed");
        free_canvas(&canvas);
        exit(EXIT_FAILURE);
    }

    // Create the display thread
    rc = pthread_create(&display_thread, NULL, display_canvas, NULL);
    if(rc) {
        fprintf(stderr, "Error: Unable to create display thread, return code %d\n", rc);
        pthread_mutex_destroy(&canvas_mutex);
        free_canvas(&canvas);
        exit(EXIT_FAILURE);
    }

    // Create drawing threads
    for(long t = 0; t < NUM_DRAWING_THREADS; t++) {
        rc = pthread_create(&drawing_threads[t], NULL, draw_rectangles, (void*)t);
        if(rc) {
            fprintf(stderr, "Error: Unable to create drawing thread %ld, return code %d\n", t, rc);
            // Signal display thread to terminate
            pthread_mutex_lock(&canvas_mutex);
            drawing_complete = 1;
            pthread_mutex_unlock(&canvas_mutex);
            pthread_join(display_thread, NULL);
            pthread_mutex_destroy(&canvas_mutex);
            free_canvas(&canvas);
            exit(EXIT_FAILURE);
        }
    }

    // Wait for all drawing threads to finish
    for(int t = 0; t < NUM_DRAWING_THREADS; t++) {
        pthread_join(drawing_threads[t], NULL);
    }

    // Signal the display thread to terminate
    pthread_mutex_lock(&canvas_mutex);
    drawing_complete = 1;
    pthread_mutex_unlock(&canvas_mutex);

    // Wait for the display thread to finish
    pthread_join(display_thread, NULL);

    // Final display of the canvas
    print_canvas(&canvas);

    // Destroy the mutex
    pthread_mutex_destroy(&canvas_mutex);

    // Free the canvas memory
    free_canvas(&canvas);

    printf("Multithreaded drawing simulation completed.\n");
    return 0;
}

/*
 * 10-spinners.c — Multiple concurrent spinner animations
 *
 * Key concepts: Thread-per-spinner, ANSI escape codes, usleep timing
 * Compile: gcc -o spinners 10-spinners.c -lpthread
 * Run:     ./prog
 */
// File: multithreaded_spinner_animation.c
// Compile with: gcc -Wall -pthread -o multithreaded_spinner_animation multithreaded_spinner_animation.c

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>

// Define the number of spinner threads
#define NUM_SPINNERS 35

// Define spinner characters for animation
const char spinner_chars[] = {'|', '/', '-', '\\'};
const int NUM_SPINNER_CHARS = sizeof(spinner_chars) / sizeof(spinner_chars[0]);

// Structure to pass spinner information to threads
typedef struct {
    int spinner_id;
    int line_number;
} spinner_info_t;

// Mutex to protect terminal writes
pthread_mutex_t terminal_mutex;

// Flag to signal spinner threads to stop
volatile int stop_flag = 0;

// Function to hide the cursor
void hide_cursor() {
    printf("\033[?25l");
}

// Function to show the cursor
void show_cursor() {
    printf("\033[?25h");
}

// Function to clear the screen
void clear_screen() {
    printf("\033[2J");
}

// Function to move the cursor to a specific position
void move_cursor(int line, int column) {
    printf("\033[%d;%dH", line, column);
}

// Spinner thread function
void* spinner_thread(void* arg) {
    spinner_info_t* info = (spinner_info_t*)arg;
    int spinner_id = info->spinner_id;
    int line = info->line_number;
    int spinner_index = 0;

    while(!stop_flag) {
        // Lock the mutex before writing to the terminal
        pthread_mutex_lock(&terminal_mutex);

        // Move cursor to the designated line and column
        move_cursor(line, 1);

        // Print the spinner character
        printf("Spinner %d: %c", spinner_id, spinner_chars[spinner_index]);

        // Flush the output to ensure real-time display
        fflush(stdout);

        // Unlock the mutex after writing
        pthread_mutex_unlock(&terminal_mutex);

        // Update spinner index for next character
        spinner_index = (spinner_index + 1) % NUM_SPINNER_CHARS;

        // Sleep for a short duration to control spinner speed
        usleep(100000); // 100 ms
    }

    // Clear the spinner line upon termination
    pthread_mutex_lock(&terminal_mutex);
    move_cursor(line, 1);
    printf("Spinner %d:   ", spinner_id);
    fflush(stdout);
    pthread_mutex_unlock(&terminal_mutex);

    pthread_exit(NULL);
}

// Controller thread function to stop the animation after a duration
void* controller_thread(void* arg) {
    int duration = *((int*)arg);
    sleep(duration);
    stop_flag = 1;
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Concurrent Spinner Animations\n");
    printf("══════════════════════════════════════\n\n");
    pthread_t spinners[NUM_SPINNERS];
    pthread_t controller;
    spinner_info_t spinner_infos[NUM_SPINNERS];
    int rc;
    int animation_duration = 5; // Duration in seconds

    // Initialize the mutex
    if(pthread_mutex_init(&terminal_mutex, NULL) != 0) {
        perror("Mutex initialization failed");
        exit(EXIT_FAILURE);
    }

    // Clear the screen and hide the cursor
    clear_screen();
    hide_cursor();

    // Initialize spinner threads
    for(long i = 0; i < NUM_SPINNERS; i++) {
        spinner_infos[i].spinner_id = i + 1;
        spinner_infos[i].line_number = i + 1; // Assign each spinner to its own line
        rc = pthread_create(&spinners[i], NULL, spinner_thread, (void*)&spinner_infos[i]);
        if(rc) {
            fprintf(stderr, "Error: Unable to create spinner thread %ld, return code %d\n", i, rc);
            stop_flag = 1;
            // Join already created threads before exiting
            for(int j = 0; j < i; j++) {
                pthread_join(spinners[j], NULL);
            }
            pthread_mutex_destroy(&terminal_mutex);
            show_cursor();
            exit(EXIT_FAILURE);
        }
        sleep(1); // Stagger spinner thread creation by 1 second
    }

    // Create the controller thread
    rc = pthread_create(&controller, NULL, controller_thread, (void*)&animation_duration);
    if(rc) {
        fprintf(stderr, "Error: Unable to create controller thread, return code %d\n", rc);
        stop_flag = 1;
        // Join spinner threads before exiting
        for(int i = 0; i < NUM_SPINNERS; i++) {
            pthread_join(spinners[i], NULL);
        }
        pthread_mutex_destroy(&terminal_mutex);
        show_cursor();
        exit(EXIT_FAILURE);
    }

    // Wait for the controller thread to finish
    pthread_join(controller, NULL);

    // Wait for all spinner threads to finish
    for(int i = 0; i < NUM_SPINNERS; i++) {
        pthread_join(spinners[i], NULL);
    }

    // Show the cursor again before exiting
    show_cursor();

    // Move the cursor below the spinners
    move_cursor(NUM_SPINNERS + 2, 1);
    printf("Animation complete. Exiting...\n");

    // Destroy the mutex
    pthread_mutex_destroy(&terminal_mutex);

    return 0;
}