Pthread Deep Dive Tutorial Pthread 深度教程

#include 
#include 
#include 

#define QUOTA 10
#define FILE_NOT_FOUND -1
#define QUOTA_EXCEEDED_MESSAGE "Quota exceeded!"
#define QUOTA_RESOLVED_MESSAGE "Quota resolved!"

// Shared data (needs protection)
int total_size = 0;
int warning_printed = 0;

// Mutex lock (like a key)
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

// Thread function: monitor one file
void *watch_file(void *arg) {
    char *filename = (char *)arg;

    printf("Thread starts monitoring: %s\n", filename);

    // Keep monitoring until file is deleted
    while (1) {
        int size = file_size(filename);

        if (size == FILE_NOT_FOUND) {
            printf("File %s deleted, thread exits\n", filename);
            break;
        }

        // ========== Critical Section: Use lock to protect shared data ==========
        // 🔒 Acquire lock (only one thread can enter)
        pthread_mutex_lock(&lock);

        // Update total size
        total_size += size;

        // Check if exceeds quota
        if (total_size > QUOTA && !warning_printed) {
            printf("%s\n", QUOTA_EXCEEDED_MESSAGE);
            warning_printed = 1;
        } else if (total_size <= QUOTA && warning_printed) {
            printf("%s\n", QUOTA_RESOLVED_MESSAGE);
            warning_printed = 0;
        }

        // 🔓 Release lock (let others use)
        pthread_mutex_unlock(&lock);

        // Wait before checking again
        usleep(100000);  // 0.1 second
    }

    return NULL;
}

int main(void) {
    char *files[] = {"file1", "file2", "file3"};
    int num_files = 3;
    pthread_t threads[num_files];

    // Create monitoring thread for each file
    for (int i = 0; i < num_files; i++) {
        pthread_create(&threads[i], NULL, watch_file, files[i]);
    }

    // Wait for all threads to complete
    for (int i = 0; i < num_files; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

/*
 * Key Concepts:
 *
 * 1. What is a race condition?
 *    Imagine you and friend both putting money in same piggy bank:
 *    - You see $10 in piggy bank
 *    - Friend also sees $10 (not updated yet)
 *    - You add $5, write back $15
 *    - Friend adds $3, writes back $13 (overwrites yours!)
 *    - Should be $18, but only $13
 *
 * 2. How does mutex work?
 *    - Like a key, only one person can hold it
 *    - Person with key can modify data
 *    - After modification, return key for next person
 *    - This prevents conflicts
 *
 * 3. Why need warning_printed flag?
 *    - Avoid printing same message repeatedly
 *    - Only print when state changes
 *
 * 4. Why use usleep?
 *    - Let thread rest, don't check too frequently
 *    - Reduces CPU usage
 *    - Also reduces file system load
 */

#include 
#include 
#include 
#include 

#define QUOTA 10
#define FILE_NOT_FOUND -1
#define QUOTA_EXCEEDED_MESSAGE "Quota exceeded!"
#define QUOTA_RESOLVED_MESSAGE "Quota resolved!"

// Shared data (using atomic types)
atomic_int total_size = 0;
atomic_int warning_printed = 0;

void *watch_file(void *arg) {
    char *filename = (char *)arg;

    while (1) {
        int size = file_size(filename);

        if (size == FILE_NOT_FOUND) {
            break;
        }

        // ========== Atomic operations: Safe without locks ==========
        // Atomic operation: safely add to total
        atomic_fetch_add(&total_size, size);

        // Read current values
        int current_total = atomic_load(&total_size);
        int warned = atomic_load(&warning_printed);

        // Check quota
        if (current_total > QUOTA && !warned) {
            // Atomic: set warning flag (if not already set)
            int expected = 0;
            if (atomic_compare_exchange_strong(&warning_printed, &expected, 1)) {
                // Only first thread reaching here prints
                printf("%s\n", QUOTA_EXCEEDED_MESSAGE);
            }
        } else if (current_total <= QUOTA && warned) {
            // Atomic: clear warning flag
            int expected = 1;
            if (atomic_compare_exchange_strong(&warning_printed, &expected, 0)) {
                printf("%s\n", QUOTA_RESOLVED_MESSAGE);
            }
        }

        usleep(100000);
    }

    return NULL;
}

int main(void) {
    char *files[] = {"file1", "file2", "file3"};
    int num_files = 3;
    pthread_t threads[num_files];

    for (int i = 0; i < num_files; i++) {
        pthread_create(&threads[i], NULL, watch_file, files[i]);
    }

    for (int i = 0; i < num_files; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}