什么是线程安全--互斥锁，条件变量，读写锁，死锁与活锁

三玖诶

已于 2024-09-12 20:08:21 修改

阅读量709

点赞数 25

分类专栏： C C进阶文章标签： linux c 线程开发语言

于 2024-09-12 20:06:33 首次发布

本文链接：https://blog.csdn.net/weixin_65477256/article/details/142184448

版权

C 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

C进阶

9 篇文章 0 订阅

订阅专栏

线程安全是多线程编程中的一个重要概念，确保在多个线程并发执行时，数据的一致性和正确性。以下是一些关于C语言中线程安全的关键点：

1. 什么是线程安全

线程安全意味着一个函数或代码块可以被多个线程同时调用而不会引发竞争条件或数据不一致的问题。换句话说，线程安全的代码在多线程环境下能够正确地执行，而不会产生错误的结果或导致程序崩溃。

2. 竞争条件

竞争条件发生在两个或多个线程同时访问共享资源时，而至少有一个线程会对资源进行修改。如果访问这些共享资源的操作没有得到适当的同步，程序的行为可能会不可预测或错误。例如，两个线程同时更新一个全局变量而没有加锁，可能会导致变量值丢失或数据损坏。

好的，下面是对各个函数中参数的详细讲解：

1. 互斥锁（Mutex）

pthread_mutex_init(&mutex, NULL)
- &mutex：指向互斥锁对象的指针。在调用此函数前，互斥锁对象未被初始化。
- NULL：表示使用默认的互斥锁属性。可以通过 pthread_mutexattr_t 结构体设置其他属性。
pthread_mutex_lock(&mutex)
- &mutex：指向要锁定的互斥锁对象的指针。调用此函数会试图获得互斥锁，若锁已被其他线程持有，当前线程会被阻塞，直到锁可用。
pthread_mutex_unlock(&mutex)
- &mutex：指向要解锁的互斥锁对象的指针。调用此函数会释放互斥锁，允许其他线程获取锁。
pthread_mutex_destroy(&mutex)
- &mutex：指向要销毁的互斥锁对象的指针。调用此函数后，互斥锁不再可用，通常在程序结束或不再需要互斥锁时调用。

特点

互斥锁（pthread_mutex_t）是最基本的同步机制，确保在任何时刻只有一个线程可以访问共享资源。
简单易用，适用于需要保护临界区的情况。

优点

保证互斥，防止多个线程同时访问共享资源导致的数据不一致。
实现简单，适用广泛。

缺点

如果使用不当（例如频繁锁定和解锁），可能导致性能问题。
可能导致死锁，如果线程在持有锁的情况下等待另一个锁。

最佳使用场景

当你需要确保对共享资源的互斥访问时，例如修改全局变量或写入文件。
适用于保护较小的临界区（即被多个线程共享的资源）。

2. 条件变量（Condition Variables）

pthread_cond_init(&cond, NULL)
- &cond：指向条件变量对象的指针。在调用此函数前，条件变量对象未被初始化。
- NULL：表示使用默认的条件变量属性。可以通过 pthread_condattr_t 结构体设置其他属性。
pthread_cond_wait(&cond, &mutex)
- &cond：指向要等待的条件变量对象的指针。线程调用此函数时会进入等待状态，直到条件变量被信号唤醒。
- &mutex：指向与条件变量配对的互斥锁对象的指针。在等待条件变量期间，互斥锁会被释放，等待结束后，互斥锁会重新被锁定。
pthread_cond_signal(&cond)
- &cond：指向要发送信号的条件变量对象的指针。调用此函数会唤醒一个正在等待该条件变量的线程。
pthread_cond_broadcast(&cond)
- &cond：指向要发送广播信号的条件变量对象的指针。调用此函数会唤醒所有正在等待该条件变量的线程。
pthread_cond_destroy(&cond)
- &cond：指向要销毁的条件变量对象的指针。调用此函数后，条件变量不再可用，通常在程序结束或不再需要条件变量时调用。

特点

条件变量（pthread_cond_t）用于线程间的同步，允许线程在某个条件发生时进行等待或唤醒。
通常与互斥锁一起使用。

优点

适用于需要线程等待某个条件的场景，例如生产者-消费者模式中的线程等待缓冲区不为空或不满。
能有效减少线程的忙等待，降低CPU的占用率。

缺点

使用较复杂，需要配合互斥锁使用。
需要管理等待和唤醒的逻辑，容易出错。

最佳使用场景

当线程需要等待某个条件才能继续执行，例如生产者线程等待缓冲区有足够空间，消费者线程等待缓冲区有数据。
适用于需要线程间协调的复杂场景。

3. 读写锁（Read-Write Locks）

pthread_rwlock_init(&rwlock, NULL)
- &rwlock：指向读写锁对象的指针。在调用此函数前，读写锁对象未被初始化。
- NULL：表示使用默认的读写锁属性。可以通过 pthread_rwlockattr_t 结构体设置其他属性。
pthread_rwlock_rdlock(&rwlock)
- &rwlock：指向要获取读锁的读写锁对象的指针。调用此函数会获取读锁，允许多个线程同时读取，但不允许写操作。
pthread_rwlock_wrlock(&rwlock)
- &rwlock：指向要获取写锁的读写锁对象的指针。调用此函数会获取写锁，写操作需要独占访问，期间不允许其他线程读取或写入。
pthread_rwlock_unlock(&rwlock)
- &rwlock：指向要释放的读写锁对象的指针。调用此函数会释放当前线程持有的锁，无论是读锁还是写锁。
pthread_rwlock_destroy(&rwlock)
- &rwlock：指向要销毁的读写锁对象的指针。调用此函数后，读写锁不再可用，通常在程序结束或不再需要读写锁时调用。

特点

读写锁（pthread_rwlock_t）允许多个线程同时读取共享资源，但写操作需要独占访问。
适用于读操作远多于写操作的情况。

优点

提高了读操作的并发性，多个线程可以同时读取数据。
在读多写少的场景中，性能显著优于互斥锁。

缺点

实现复杂，比互斥锁开销更大。
写操作可能会导致读锁和写锁的争用，从而影响性能。

最佳使用场景

当共享资源的读操作远多于写操作时，例如缓存的读取和更新。
适用于需要高效读操作的场景，如共享数据的统计信息。

4. 原子操作（Atomic Operations）

atomic_load(&variable)
- &variable：指向要读取的原子变量的指针。调用此函数会原子地加载变量的值，确保在多线程环境中读取操作的正确性。
atomic_store(&variable, value)
- &variable：指向要存储值的原子变量的指针。调用此函数会原子地将 value 存储到变量中，确保在多线程环境中存储操作的正确性。
- value：要存储到原子变量的值。
atomic_exchange(&variable, value)
- &variable：指向要交换值的原子变量的指针。调用此函数会原子地将 variable 的当前值替换为 value，并返回原来的值。
atomic_fetch_add(&variable, value)
- &variable：指向要增加值的原子变量的指针。调用此函数会原子地将 value 加到 variable 上，并返回 variable 原来的值。

特点

原子操作是不可被中断的操作，确保在多线程环境中操作的原子性。
常用于处理简单的数据类型（如整数）并确保操作的安全性。

优点

执行速度快，开销小，适用于频繁更新的小数据类型。
不需要锁，减少了上下文切换的开销。

缺点

适用于简单数据类型和操作，复杂操作无法用原子操作实现。
不适用于需要保护大范围数据或多个操作的场景。

最佳使用场景

当你需要频繁更新简单数据类型（如计数器）并希望避免锁的开销时。
适用于高性能的计数器、标志位等小范围的共享数据。

5. 线程局部存储（Thread-Local Storage）

_Thread_local int thread_local_var
- _Thread_local：表示变量 thread_local_var 是线程局部存储的，意味着每个线程都有自己独立的 thread_local_var 副本。
- thread_local_var：声明的线程局部存储变量。每个线程在访问时会操作自己的副本，而不是共享的全局变量。

特点

线程局部存储允许每个线程有自己的独立变量副本，避免了多线程之间的数据共享问题。

优点

避免了多线程间的数据竞争，因为每个线程都有自己的变量副本。
简化了线程间的数据管理。

缺点

变量副本可能会导致内存消耗增加，尤其是当线程数量很大时。
不适用于需要多个线程共享的变量。

最佳使用场景

当每个线程需要维护自己的独立状态信息时，例如线程特定的日志记录器或数据库连接。
适用于需要避免线程间共享数据的场景，如线程私有的配置信息。

6. 死锁和活锁

死锁

死锁：两个或多个线程因互相持有对方所需的资源而进入无限等待状态。解决死锁的方法包括避免循环等待、使用超时机制等。

活锁

活锁：线程由于不断尝试获得资源而导致无法继续执行。解决活锁的方法包括重试机制和回退策略。

总结

线程安全是多线程编程的核心，涉及到数据一致性和同步机制的正确使用。通过使用互斥锁、条件变量、读写锁、原子操作以及线程局部存储，可以有效地管理并发访问问题，确保多线程程序的正确性和稳定性。

代码示例

下面是对先前示例代码的详细注释版，以帮助更好地理解每个部分的功能和作用。

1. 互斥锁（Mutex）示例

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

// 互斥锁定义
pthread_mutex_t mutex;
int counter = 0; // 共享计数器

// 线程函数：增加计数器
void *increment(void *arg) {
    for (int i = 0; i < 10000; i++) {
        pthread_mutex_lock(&mutex); // 加锁
        counter++; // 修改共享资源
        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);

    printf("Final counter value: %d\n", counter); // 输出最终计数器值

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

2. 条件变量（Condition Variables）示例

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

#define MAXSUMS 10 // 仓库最大容量
#define MINSUMS 0  // 仓库最小容量

pthread_cond_t cond; // 条件变量
pthread_mutex_t mutex; // 互斥锁
int stock = 0; // 当前库存量

// 生产者线程函数
void *producer(void *arg) {
    while (1) {
        pthread_mutex_lock(&mutex); // 加锁
        while (stock >= MAXSUMS) { // 仓库满时等待
            printf("Warehouse full, producer %s is waiting.\n", (char *)arg);
            pthread_cond_wait(&cond, &mutex); // 等待条件变量
        }
        stock++; // 生产商品
        printf("Producer %s produced an item, stock: %d\n", (char *)arg, stock);
        pthread_cond_signal(&cond); // 唤醒等待的线程
        pthread_mutex_unlock(&mutex); // 解锁
        usleep(100000); // 模拟工作
    }
    return NULL;
}

// 消费者线程函数
void *consumer(void *arg) {
    while (1) {
        pthread_mutex_lock(&mutex); // 加锁
        while (stock <= MINSUMS) { // 仓库空时等待
            printf("Warehouse empty, consumer %s is waiting.\n", (char *)arg);
            pthread_cond_wait(&cond, &mutex); // 等待条件变量
        }
        stock--; // 消费商品
        printf("Consumer %s consumed an item, stock: %d\n", (char *)arg, stock);
        pthread_cond_signal(&cond); // 唤醒等待的线程
        pthread_mutex_unlock(&mutex); // 解锁
        usleep(300000); // 模拟工作
    }
    return NULL;
}

int main() {
    pthread_t p1, p2, c1, c2;
    pthread_cond_init(&cond, NULL); // 初始化条件变量
    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁

    // 创建生产者线程
    pthread_create(&p1, NULL, producer, "P1");
    pthread_create(&p2, NULL, producer, "P2");

    // 创建消费者线程
    pthread_create(&c1, NULL, consumer, "C1");
    pthread_create(&c2, NULL, consumer, "C2");

    // 等待线程完成
    pthread_join(p1, NULL);
    pthread_join(p2, NULL);
    pthread_join(c1, NULL);
    pthread_join(c2, NULL);

    pthread_cond_destroy(&cond); // 销毁条件变量
    pthread_mutex_destroy(&mutex); // 销毁互斥锁

    return 0;
}

3. 读写锁（Read-Write Locks）示例

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

#define READERS 5 // 读线程数量
#define WRITERS 2 // 写线程数量

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

// 读线程函数
void *reader(void *arg) {
    while (1) {
        pthread_rwlock_rdlock(&rwlock); // 获取读锁
        printf("Reader %d read data: %d\n", (int)(size_t)arg, shared_data);
        pthread_rwlock_unlock(&rwlock); // 释放读锁
        usleep(500000); // 模拟工作
    }
    return NULL;
}

// 写线程函数
void *writer(void *arg) {
    while (1) {
        pthread_rwlock_wrlock(&rwlock); // 获取写锁
        shared_data++; // 写入数据
        printf("Writer %d wrote data: %d\n", (int)(size_t)arg, shared_data);
        pthread_rwlock_unlock(&rwlock); // 释放写锁
        usleep(1000000); // 模拟工作
    }
    return NULL;
}

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

    // 创建读线程
    for (int i = 0; i < READERS; i++) {
        pthread_create(&readers[i], NULL, reader, (void *)(size_t)i);
    }

    // 创建写线程
    for (int i = 0; i < WRITERS; i++) {
        pthread_create(&writers[i], NULL, writer, (void *)(size_t)i);
    }

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

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

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

    return 0;
}

4. 原子操作（Atomic Operations）示例

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

atomic_int counter = 0; // 原子计数器

// 线程函数：增加计数器
void *increment(void *arg) {
    for (int i = 0; i < 10000; i++) {
        atomic_fetch_add(&counter, 1); // 原子地增加计数器
    }
    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 counter value: %d\n", atomic_load(&counter)); // 输出最终计数器值

    return 0;
}

5. 线程局部存储（Thread-Local Storage）示例

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

_Thread_local int thread_local_var = 0; // 线程局部存储变量

// 线程函数
void *thread_func(void *arg) {
    thread_local_var = (int)(size_t)arg; // 设置线程局部存储变量
    printf("Thread %d, thread_local_var: %d\n", (int)(size_t)arg, thread_local_var);
    return NULL;
}

int main() {
    pthread_t threads[3];

    // 创建线程
    for (int i = 0; i < 3; i++) {
        pthread_create(&threads[i], NULL, thread_func, (void *)(size_t)i);
    }

    // 等待线程完成
    for (int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

总结

上述示例代码展示了如何使用不同的同步机制确保线程安全。通过注释解释了每个同步机制的功能和使用方法，这将有助于深入理解线程安全的实现和管理。每个示例演示了在多线程环境中如何使用适当的工具来保证数据一致性和程序的稳定性。

三玖诶

关注

25
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
什么是线程安全--互斥锁，条件变量，读写锁，死锁与活锁

线程安全是多线程编程的核心，涉及到数据一致性和同步机制的正确使用。通过使用互斥锁、条件变量、读写锁、原子操作以及线程局部存储，可以有效地管理并发访问问题，确保多线程程序的正确性和稳定性。上述示例代码展示了如何使用不同的同步机制确保线程安全。通过注释解释了每个同步机制的功能和使用方法，这将有助于深入理解线程安全的实现和管理。每个示例演示了在多线程环境中如何使用适当的工具来保证数据一致性和程序的稳定性。
复制链接

扫一扫