Linux C语言多线程数据共享的处理

多线程数据共享概述

在 Linux C 语言多线程编程中，数据共享是一个关键且复杂的问题。当多个线程同时访问和操作共享数据时，可能会引发一系列问题，如数据竞争（race condition）、不一致状态等。

数据竞争

数据竞争发生在多个线程同时对共享数据进行读写操作时，其执行顺序的不确定性会导致最终结果的不可预测性。例如，假设有一个全局变量 count，两个线程都对其进行自增操作：

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

int count = 0;

void* increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        count++;
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    pthread_create(&thread1, NULL, increment, NULL);
    pthread_create(&thread2, NULL, increment, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    printf("Final count: %d\n", count);
    return 0;
}

理论上，如果没有数据竞争，count 最终应该是 2000000。但实际运行该程序，每次得到的结果可能都不一样，因为 count++ 操作并非原子操作，它由读取 count 值、增加 1、写回 count 三个步骤组成。在多线程环境下，当一个线程执行完读取操作，还未完成写回操作时，另一个线程可能也开始读取 count，这样就会导致数据的不一致。

不一致状态

除了数据竞争，多线程对共享数据的操作还可能导致不一致状态。例如，一个线程负责更新一个复杂数据结构的多个相关字段，在更新过程中，其他线程读取该数据结构，可能会看到部分更新后的状态，从而导致程序逻辑错误。

解决数据共享问题的方法

为了解决多线程数据共享带来的问题，通常采用同步机制。在 Linux C 语言中，常用的同步机制包括互斥锁（mutex）、读写锁（rwlock）、条件变量（condition variable）等。

互斥锁（Mutex）

互斥锁是一种最基本的同步工具，它保证在同一时间只有一个线程能够访问共享资源。互斥锁有两种状态：锁定（locked）和解锁（unlocked）。当一个线程获取（lock）了互斥锁，其他线程试图获取该互斥锁时将被阻塞，直到该互斥锁被释放（unlock）。

互斥锁的使用

1. 初始化互斥锁：在使用互斥锁之前，需要对其进行初始化。可以使用 pthread_mutex_init 函数进行初始化：

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);

这里第二个参数 NULL 表示使用默认属性。

2. 获取互斥锁：使用 pthread_mutex_lock 函数获取互斥锁：

pthread_mutex_lock(&mutex);

如果互斥锁已经被其他线程锁定，调用该函数的线程将被阻塞，直到互斥锁被释放。

3. 释放互斥锁：使用 pthread_mutex_unlock 函数释放互斥锁：

pthread_mutex_unlock(&mutex);

4. 销毁互斥锁：当不再需要互斥锁时，使用 pthread_mutex_destroy 函数销毁它：

pthread_mutex_destroy(&mutex);

使用互斥锁解决数据竞争问题

回到之前 count 自增的例子，通过添加互斥锁来解决数据竞争问题：

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

int count = 0;
pthread_mutex_t mutex;

void* increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&mutex);
        count++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, NULL);

    pthread_create(&thread1, NULL, increment, NULL);
    pthread_create(&thread2, NULL, increment, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    pthread_mutex_destroy(&mutex);
    printf("Final count: %d\n", count);
    return 0;
}

在这个例子中，每次 count++ 操作前获取互斥锁，操作完成后释放互斥锁，这样就保证了同一时间只有一个线程能够修改 count，从而避免了数据竞争。

读写锁（RWLock）

读写锁适用于一种常见的场景：共享数据的读取操作远远多于写入操作。读写锁允许多个线程同时进行读操作，但只允许一个线程进行写操作，并且在写操作进行时，不允许任何读操作。

读写锁的使用

1. 初始化读写锁：使用 pthread_rwlock_init 函数初始化读写锁：

pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);

2. 获取读锁：使用 pthread_rwlock_rdlock 函数获取读锁：

pthread_rwlock_rdlock(&rwlock);

多个线程可以同时获取读锁，只要没有线程持有写锁。

3. 获取写锁：使用 pthread_rwlock_wrlock 函数获取写锁：

pthread_rwlock_wrlock(&rwlock);

如果有其他线程持有读锁或写锁，调用该函数的线程将被阻塞。

4. 释放锁：无论是读锁还是写锁，都使用 pthread_rwlock_unlock 函数释放：

pthread_rwlock_unlock(&rwlock);

5. 销毁读写锁：使用 pthread_rwlock_destroy 函数销毁读写锁：

pthread_rwlock_destroy(&rwlock);

读写锁示例

假设我们有一个共享的缓存数据结构，多个线程可能读取该缓存，而偶尔有一个线程会更新缓存：

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

int cache = 0;
pthread_rwlock_t rwlock;

void* read_cache(void* arg) {
    pthread_rwlock_rdlock(&rwlock);
    printf("Read cache: %d\n", cache);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

void* write_cache(void* arg) {
    pthread_rwlock_wrlock(&rwlock);
    cache = 42;
    printf("Write cache: %d\n", cache);
    pthread_rwlock_unlock(&rwlock);
    return NULL;
}

int main() {
    pthread_t readers[5], writer;
    pthread_rwlock_init(&rwlock, NULL);

    for (int i = 0; i < 5; i++) {
        pthread_create(&readers[i], NULL, read_cache, NULL);
    }
    pthread_create(&writer, NULL, write_cache, NULL);

    for (int i = 0; i < 5; i++) {
        pthread_join(readers[i], NULL);
    }
    pthread_join(writer, NULL);

    pthread_rwlock_destroy(&rwlock);
    return 0;
}

在这个例子中，读操作使用读锁，允许多个线程同时读取缓存；写操作使用写锁，保证在写操作时没有其他线程可以访问缓存，从而保证数据的一致性。

条件变量（Condition Variable）

条件变量用于线程间的同步，它允许线程等待某个条件满足后再继续执行。条件变量通常与互斥锁一起使用。

条件变量的使用

1. 初始化条件变量：使用 pthread_cond_init 函数初始化条件变量：

pthread_cond_t cond;
pthread_cond_init(&cond, NULL);

2. 等待条件变量：线程使用 pthread_cond_wait 函数等待条件变量。该函数会自动释放与其关联的互斥锁，并将线程阻塞，直到条件变量被信号唤醒。当线程被唤醒后，pthread_cond_wait 函数会重新获取互斥锁。

pthread_mutex_lock(&mutex);
while (condition_not_met) {
    pthread_cond_wait(&cond, &mutex);
}
// 条件满足后执行的代码
pthread_mutex_unlock(&mutex);

这里使用 while 循环而不是 if 语句是为了防止虚假唤醒（spurious wakeup），即线程可能在条件未满足时就被唤醒。

3. 唤醒条件变量：其他线程可以使用 pthread_cond_signal 函数唤醒一个等待条件变量的线程，或者使用 pthread_cond_broadcast 函数唤醒所有等待条件变量的线程。

pthread_mutex_lock(&mutex);
// 改变条件
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);

4. 销毁条件变量：使用 pthread_cond_destroy 函数销毁条件变量：

pthread_cond_destroy(&cond);

条件变量示例

假设有一个生产者 - 消费者模型，生产者线程生产数据并放入共享缓冲区，消费者线程从缓冲区取出数据。当缓冲区为空时，消费者线程需要等待生产者线程生产数据：

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

#define BUFFER_SIZE 5
int buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int count = 0;

pthread_mutex_t mutex;
pthread_cond_t cond_empty, cond_full;

void* producer(void* arg) {
    for (int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mutex);
        while (count == BUFFER_SIZE) {
            pthread_cond_wait(&cond_empty, &mutex);
        }
        buffer[in] = i;
        printf("Produced: %d\n", buffer[in]);
        in = (in + 1) % BUFFER_SIZE;
        count++;
        pthread_cond_signal(&cond_full);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void* consumer(void* arg) {
    for (int i = 0; i < 10; i++) {
        pthread_mutex_lock(&mutex);
        while (count == 0) {
            pthread_cond_wait(&cond_full, &mutex);
        }
        int value = buffer[out];
        printf("Consumed: %d\n", value);
        out = (out + 1) % BUFFER_SIZE;
        count--;
        pthread_cond_signal(&cond_empty);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t producer_thread, consumer_thread;
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_empty, NULL);
    pthread_cond_init(&cond_full, NULL);

    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_empty);
    pthread_cond_destroy(&cond_full);
    return 0;
}

在这个例子中，生产者线程在缓冲区满时等待 cond_empty 条件变量，消费者线程在缓冲区空时等待 cond_full 条件变量，通过条件变量实现了生产者 - 消费者之间的同步。

线程局部存储（TLS）

除了使用同步机制来处理共享数据，还可以通过线程局部存储（Thread - Local Storage，TLS）来避免数据共享问题。TLS 允许每个线程拥有自己独立的变量副本，不同线程对该变量的操作不会相互影响。

TLS 的使用

1. 定义 TLS 键：使用 pthread_key_create 函数创建一个 TLS 键：

pthread_key_t key;
pthread_key_create(&key, NULL);

第二个参数可以指定一个析构函数，当线程结束时，该析构函数会被调用以释放与该 TLS 键相关的资源。

2. 设置 TLS 值：使用 pthread_setspecific 函数为当前线程设置 TLS 值：

pthread_setspecific(key, &thread_specific_variable);

3. 获取 TLS 值：使用 pthread_getspecific 函数获取当前线程的 TLS 值：

void* value = pthread_getspecific(key);

4. 删除 TLS 键：使用 pthread_key_delete 函数删除 TLS 键：

pthread_key_delete(key);

TLS 示例

假设每个线程需要一个独立的计数器：

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

pthread_key_t key;

void* thread_function(void* arg) {
    int* thread_count = (int*)pthread_getspecific(key);
    if (thread_count == NULL) {
        thread_count = (int*)malloc(sizeof(int));
        *thread_count = 0;
        pthread_setspecific(key, thread_count);
    }
    (*thread_count)++;
    printf("Thread %ld count: %d\n", pthread_self(), *thread_count);
    return NULL;
}

int main() {
    pthread_t threads[5];
    pthread_key_create(&key, free);

    for (int i = 0; i < 5; i++) {
        pthread_create(&threads[i], NULL, thread_function, NULL);
    }

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

    pthread_key_delete(key);
    return 0;
}

在这个例子中，每个线程都有自己独立的 thread_count 变量，通过 TLS 实现了数据的独立，避免了数据共享带来的问题。

多线程数据共享的性能考虑

在使用同步机制解决多线程数据共享问题时，需要考虑性能问题。过多或不合理地使用同步机制可能会导致性能瓶颈。

锁的粒度

锁的粒度是指一次锁定所保护的数据范围。锁的粒度过大，会导致很多线程在等待锁，降低并发度；锁的粒度过小，可能会增加锁的开销。例如，在一个复杂的数据结构中，如果对整个数据结构加锁，可能会影响性能，此时可以考虑对数据结构的不同部分分别加锁，以提高并发度。

读写比例

对于读写锁，要根据实际应用中读写操作的比例来合理使用。如果读操作远多于写操作，使用读写锁可以显著提高性能；但如果读写操作比例接近，读写锁的优势可能不明显，甚至可能因为锁的开销而降低性能。

条件变量的使用时机

条件变量的使用应该谨慎，避免不必要的等待和唤醒。在设置条件变量的条件时，要确保条件的准确性，尽量减少虚假唤醒的可能性，以提高程序的性能。

线程局部存储的开销

虽然线程局部存储避免了数据共享问题，但也带来了一定的开销，如 TLS 键的创建、设置和获取操作。在使用 TLS 时，要评估这些开销对程序性能的影响，确保其使用是合理的。

多线程数据共享的常见错误及避免方法

在多线程数据共享编程中，有一些常见的错误需要注意。

死锁

死锁是指两个或多个线程相互等待对方释放锁，导致所有线程都无法继续执行的情况。例如，线程 A 持有锁 1 并等待锁 2，而线程 B 持有锁 2 并等待锁 1，就会发生死锁。

避免死锁的方法

1. 按顺序加锁：所有线程按照相同的顺序获取锁，例如总是先获取锁 1，再获取锁 2。
2. 避免嵌套锁：尽量减少在持有一个锁的情况下获取另一个锁的情况，降低死锁发生的可能性。
3. 使用超时机制：在获取锁时设置超时时间，如果在规定时间内未能获取锁，则放弃获取并采取其他措施，如释放已持有的锁。

未初始化或未销毁同步对象

如果未对互斥锁、读写锁、条件变量等同步对象进行初始化就使用，或者在不再使用后未进行销毁，可能会导致程序出现未定义行为。

避免方法

在使用同步对象前，一定要确保进行了正确的初始化；在程序结束或不再使用同步对象时，及时进行销毁。

虚假唤醒

如前文所述，条件变量可能会出现虚假唤醒的情况。如果不使用 while 循环来检查条件，可能会在条件未真正满足时就继续执行，导致程序逻辑错误。

避免方法

在等待条件变量时，始终使用 while 循环来检查条件，而不是 if 语句。

通过正确理解和应用多线程数据共享的处理方法，以及注意避免常见错误，可以编写出高效、可靠的多线程程序。在实际应用中，要根据具体的需求和场景选择合适的同步机制和方法，以实现最佳的性能和数据一致性。同时，要对程序进行充分的测试，确保在多线程环境下的正确性和稳定性。