线程安全的编程

1. 线程安全的概念

• 线程安全是指多个线程可以安全地访问同一段代码或数据，而不会造成数据不一致或程序崩溃的状态。
• 通常，线程安全的编程涉及到对共享数据的正确管理和控制。

2. 常见的线程安全问题

• 数据竞争（Data Race）：多个线程同时读写某个共享变量，导致不确定的结果。
• 死锁（Deadlock）：两个或多个线程互相等待对方释放资源，造成程序无法继续。
• 饥饿（Starvation）：某个线程会永远无法获取所需的资源。

3. 线程安全的编程原则

• 使用互斥锁（Mutex）保护共享数据。
• 使用读写锁（Read-Write Lock）来优化对共享数据的读取和写入。
• 非常规共享数据的使用，如使用消息队列或管道。

4. 互斥锁

4.1 互斥锁的概念

• 互斥锁是一种机制，用于保护共享资源，使得同一时间仅有一个线程可以访问资源。

4.2 使用互斥锁的基本步骤

1. 初始化互斥锁。
2. 在访问共享资源之前加锁。
3. 访问共享资源。
4. 访问完成后释放锁。

4.3 互斥锁示例代码

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

pthread_mutex_t lock;  // 声明互斥锁
int shared_data = 0;   // 共享数据

void* thread_function(void* arg) {
    pthread_mutex_lock(&lock);  // 加锁
    shared_data++;               // 访问共享数据
    printf("Thread %ld: shared_data = %d\n", (long)arg, shared_data);
    pthread_mutex_unlock(&lock); // 解锁
    return NULL;
}

int main() {
    pthread_t threads[10];
    pthread_mutex_init(&lock, NULL); // 初始化互斥锁

    for (long i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, thread_function, (void*)i);
    }
    
    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }

    pthread_mutex_destroy(&lock); // 销毁互斥锁
    return 0;
}

5. 读写锁

5.1 读写锁的概念

• 读写锁允许多个线程同时读取共享数据，但在写入数据时会排他性地锁住该数据。

5.2 使用读写锁的基本步骤

1. 初始化读写锁。
2. 在读取数据之前加读锁。
3. 在写入数据之前加写锁。
4. 读取/写入完成后释放锁。

5.3 读写锁示例代码

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

pthread_rwlock_t rwlock; // 声明读写锁
int shared_data = 0;     // 共享数据

void* reader(void* arg) {
    pthread_rwlock_rdlock(&rwlock); // 加读锁
    printf("Reader %ld: shared_data = %d\n", (long)arg, shared_data);
    pthread_rwlock_unlock(&rwlock); // 解锁
    return NULL;
}

void* writer(void* arg) {
    pthread_rwlock_wrlock(&rwlock); // 加写锁
    shared_data++;                   // 修改共享数据
    printf("Writer %ld: shared_data = %d\n", (long)arg);
    pthread_rwlock_unlock(&rwlock); // 解锁
    return NULL;
}

int main() {
    pthread_t readers[5], writers[5];
    pthread_rwlock_init(&rwlock, NULL); // 初始化读写锁

    // 创建读者线程
    for (long i = 0; i < 5; i++) {
        pthread_create(&readers[i], NULL, reader, (void*)i);
    }
    
    // 创建写者线程
    for (long i = 0; i < 5; i++) {
        pthread_create(&writers[i], NULL, writer, (void*)i);
    }

    // 等待所有线程完成
    for (int i = 0; i < 5; i++) {
        pthread_join(readers[i], NULL);
    }
    for (int i = 0; i < 5; i++) {
        pthread_join(writers[i], NULL);
    }

    pthread_rwlock_destroy(&rwlock); // 销毁读写锁
    return 0;
}

6. 线程安全的容器

• 考虑使用线程安全的数据结构和容器，如：
  • std::atomic（原子类型）
  • STM（软件事务内存）

7. 线程安全的编程习惯

• 尽量使用局部变量，避免全局共享数据。
• 尽可能缩小临界区的范围。
• 使用合适的锁策略，避免死锁。

8. 总结

• 线程安全是多线程编程中的关键概念，确保程序在并发环境中能够正确和有效地运行。
• 通过合理使用互斥锁、读写锁和遵循线程安全的编程原则，可以有效地避免常见的线程安全问题。