C库 —— ＜stdatomic.h＞

最新推荐文章于 2025-03-16 14:14:15 发布

新华

最新推荐文章于 2025-03-16 14:14:15 发布

阅读量2.7k

点赞数 36

分类专栏： C标准库知多少文章标签： c语言 c库

本文链接：https://blog.csdn.net/mzgxinhua/article/details/139202694

版权

C标准库知多少专栏收录该内容

134 篇文章

订阅专栏

引言

在多线程编程中，处理共享数据时需要特别注意数据的同步与一致性问题。C11标准引入了 <stdatomic.h> 头文件，用于提供一组原子操作，保证在多线程环境下的安全性和性能。掌握 <stdatomic.h> 库的功能对于编写高效且可靠的并发程序至关重要。本文将详细介绍 <stdatomic.h> 库的各个方面，包括其功能、用法以及在实际编程中的应用。

`<stdatomic.h>` 库的基本功能

<stdatomic.h> 库包含以下主要部分：

原子类型
原子操作
内存顺序
标志操作
计数操作

我们将逐一介绍这些部分的详细内容及其使用方法。

1. 原子类型

<stdatomic.h> 库定义了一些原子类型，用于确保多线程环境中的数据一致性。这些类型包括：

_Atomic：通用原子类型修饰符。
atomic_bool：原子布尔类型。
atomic_char：原子字符类型。
atomic_schar：原子有符号字符类型。
atomic_uchar：原子无符号字符类型。
atomic_short：原子短整型。
atomic_ushort：原子无符号短整型。
atomic_int：原子整型。
atomic_uint：原子无符号整型。
atomic_long：原子长整型。
atomic_ulong：原子无符号长整型。
atomic_llong：原子长长整型。
atomic_ullong：原子无符号长长整型。
atomic_wchar_t：原子宽字符类型。

示例代码：原子类型

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

int main() {
    atomic_int a = ATOMIC_VAR_INIT(0);
    atomic_bool b = ATOMIC_VAR_INIT(false);
    
    atomic_store(&a, 10);
    atomic_store(&b, true);

    printf("Atomic int: %d\n", atomic_load(&a));
    printf("Atomic bool: %d\n", atomic_load(&b));

    return 0;
}

在上面的示例中，程序使用了 atomic_int 和 atomic_bool 类型，并使用 atomic_store 和 atomic_load 函数存取原子变量的值。

2. 原子操作

<stdatomic.h> 库提供了一组原子操作函数，用于安全地操作原子类型的变量。这些操作包括：

atomic_store：原子存储操作。
atomic_load：原子加载操作。
atomic_exchange：原子交换操作。
atomic_compare_exchange_strong：强比较并交换操作。
atomic_compare_exchange_weak：弱比较并交换操作。
atomic_fetch_add：原子加操作。
atomic_fetch_sub：原子减操作。
atomic_fetch_or：原子或操作。
atomic_fetch_xor：原子异或操作。
atomic_fetch_and：原子与操作。

示例代码：原子操作

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

int main() {
    atomic_int a = ATOMIC_VAR_INIT(0);

    atomic_fetch_add(&a, 5);
    printf("Atomic fetch add: %d\n", atomic_load(&a));

    atomic_fetch_sub(&a, 3);
    printf("Atomic fetch sub: %d\n", atomic_load(&a));

    int expected = 2;
    atomic_compare_exchange_strong(&a, &expected, 10);
    printf("Atomic compare exchange strong: %d\n", atomic_load(&a));

    atomic_exchange(&a, 20);
    printf("Atomic exchange: %d\n", atomic_load(&a));

    return 0;
}

在上面的示例中，程序使用了多种原子操作函数来对原子变量进行加、减、交换和比较并交换操作。

3. 内存顺序

<stdatomic.h> 库支持指定内存顺序，以控制多线程访问共享变量的顺序。这些内存顺序包括：

memory_order_relaxed：松散顺序。
memory_order_consume：消费顺序。
memory_order_acquire：获取顺序。
memory_order_release：释放顺序。
memory_order_acq_rel：获取和释放顺序。
memory_order_seq_cst：顺序一致性。

示例代码：内存顺序

#include <stdio.h>
#include <stdatomic.h>
#include <threads.h>

atomic_int a = ATOMIC_VAR_INIT(0);
atomic_int b = ATOMIC_VAR_INIT(0);

int thread1(void *arg) {
    atomic_store_explicit(&a, 1, memory_order_relaxed);
    atomic_store_explicit(&b, 1, memory_order_release);
    return 0;
}

int thread2(void *arg) {
    while (atomic_load_explicit(&b, memory_order_acquire) == 0);
    if (atomic_load_explicit(&a, memory_order_relaxed) == 1) {
        printf("Thread2: a is 1\n");
    } else {
        printf("Thread2: a is not 1\n");
    }
    return 0;
}

int main() {
    thrd_t t1, t2;
    thrd_create(&t1, thread1, NULL);
    thrd_create(&t2, thread2, NULL);
    thrd_join(t1, NULL);
    thrd_join(t2, NULL);
    return 0;
}

在上面的示例中，程序演示了如何使用不同的内存顺序来确保多线程环境下的正确同步。

4. 标志操作

<stdatomic.h> 库提供了一些用于原子标志操作的函数，这些函数主要用于管理标志变量。这些操作包括：

atomic_flag_test_and_set：测试并设置原子标志。
atomic_flag_clear：清除原子标志。

示例代码：标志操作

#include <stdio.h>
#include <stdatomic.h>
#include <threads.h>

atomic_flag flag = ATOMIC_FLAG_INIT;

int thread_func(void *arg) {
    while (atomic_flag_test_and_set(&flag)) {
        // 旋转等待
    }
    printf("Thread %d acquired the flag\n", *(int *)arg);
    atomic_flag_clear(&flag);
    return 0;
}

int main() {
    thrd_t threads[2];
    int ids[2] = {1, 2};
    
    for (int i = 0; i < 2; i++) {
        thrd_create(&threads[i], thread_func, &ids[i]);
    }
    
    for (int i = 0; i < 2; i++) {
        thrd_join(threads[i], NULL);
    }
    
    return 0;
}

在上面的示例中，两个线程竞争一个原子标志变量，只有一个线程能够成功获取标志并进行操作。

5. 计数操作

<stdatomic.h> 库还提供了一些用于原子计数的操作，这些操作主要用于实现线程安全的计数器。常用的操作包括：

atomic_fetch_add：原子加操作。
atomic_fetch_sub：原子减操作。

示例代码：计数操作

#include <stdio.h>
#include <stdatomic.h>
#include <threads.h>

atomic_int counter = ATOMIC_VAR_INIT(0);

int thread_func(void *arg) {
    for (int i = 0; i < 1000; i++) {
        atomic_fetch_add(&counter, 1);
    }
    return 0;
}

int main() {
    thrd_t threads[10];
    
    for (int i = 0; i < 10; i++) {
        thrd_create(&threads[i], thread_func, NULL);
    }
    
    for (int i = 0; i < 10; i++) {
        thrd_join(threads[i], NULL);
    }
    
    printf("Final counter value: %d\n", atomic_load(&counter));
    return 0;
}

在上面的示例中，程序创建了10个线程，每个线程对一个共享的原子计数器进行1000次加1操作，最后输出计数器的最终值。

容易出错的使用方法

在使用 <stdatomic.h> 时，有一些常见的错误和陷阱需要注意。以下是一些容易出错的使用方法及其解决方案：

错误一：未正确使用内存顺序

在多线程环境中，未正确使用内存顺序可能会导致数据竞争和不一致的问题。

解决方案：根据具体场景正确使用内存顺序，确保线程间的同步。

示例代码：

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

atomic_int a = ATOMIC_VAR_INIT(0);
atomic_int b = ATOMIC_VAR_INIT(0);

// 错误：未正确使用内存顺序
void func1(void) {
    atomic_store(&a, 1);
    atomic_store(&b, 1);
}

void func2(void) {
    if (atomic_load(&b) == 1) {
        printf("a: %d\n", atomic_load(&a));
    }
}

int main() {
    func1();
    func2();
    return 0;
}

解决方案代码：

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

atomic_int a = ATOMIC_VAR_INIT(0);
atomic_int b = ATOMIC_VAR_INIT(0);

void func1(void) {
    atomic_store_explicit(&a, 1, memory_order_relaxed);
    atomic_store_explicit(&b, 1, memory_order_release);
}

void func2(void) {
    if (atomic_load_explicit(&b, memory_order_acquire) == 1) {
        printf("a: %d\n", atomic_load_explicit(&a, memory_order_relaxed));
    }
}

int main() {
    func1();
    func2();
    return 0;
}

在上面的解决方案中，程序使用了显式内存顺序来确保多线程环境下的正确同步。

错误二：误用原子操作

在进行原子操作时，误用原子操作函数可能会导致数据不一致或性能问题。

解决方案：根据具体需求选择合适的原子操作函数，确保操作的正确性和高效性。

示例代码：

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

atomic_int counter = ATOMIC_VAR_INIT(0);

// 错误：误用原子操作
void func(void) {
    for (int i = 0; i < 1000; i++) {
        counter++;
    }
}

int main() {
    func();
    printf("Counter: %d\n", atomic_load(&counter));
    return 0;
}

解决方案代码：

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

atomic_int counter = ATOMIC_VAR_INIT(0);

void func(void) {
    for (int i = 0; i < 1000; i++) {
        atomic_fetch_add(&counter, 1);
    }
}

int main() {
    func();
    printf("Counter: %d\n", atomic_load(&counter));
    return 0;
}

在上面的解决方案中，程序正确使用了 atomic_fetch_add 函数进行原子加操作，确保了操作的正确性和高效性。

为了更清晰地展示 `<stdatomic.h>` 库的功能和用法，我们可以使用图表进行描述。以下是一些常见用法的图表：

原子类型

类型	描述	示例值
`atomic_int`	原子整型	`atomic_int a`
`atomic_bool`	原子布尔类型	`atomic_bool b`
`atomic_char`	原子字符类型	`atomic_char c`
`atomic_long`	原子长整型	`atomic_long l`
`atomic_llong`	原子长长整型	`atomic_llong ll`
`atomic_wchar_t`	原子宽字符类型	`atomic_wchar_t w`

原子操作

操作函数	描述	示例
`atomic_store`	原子存储操作	`atomic_store(&a, 1);`
`atomic_load`	原子加载操作	`int x = atomic_load(&a);`
`atomic_exchange`	原子交换操作	`int y = atomic_exchange(&a, 2);`
`atomic_compare_exchange_strong`	强比较并交换操作	`atomic_compare_exchange_strong(&a, &x, 2);`
`atomic_fetch_add`	原子加操作	`atomic_fetch_add(&a, 1);`
`atomic_fetch_sub`	原子减操作	`atomic_fetch_sub(&a, 1);`
`atomic_fetch_or`	原子或操作	`atomic_fetch_or(&a, 0x01);`
`atomic_fetch_xor`	原子异或操作	`atomic_fetch_xor(&a, 0x01);`
`atomic_fetch_and`	原子与操作	`atomic_fetch_and(&a, 0x01);`

内存顺序

内存顺序	描述
`memory_order_relaxed`	松散顺序，不保证任何同步或顺序
`memory_order_consume`	消费顺序，保证依赖关系
`memory_order_acquire`	获取顺序，保证之前的操作不会被重排序
`memory_order_release`	释放顺序，保证之后的操作不会被重排序
`memory_order_acq_rel`	获取和释放顺序，保证双向屏障
`memory_order_seq_cst`	顺序一致性，保证全局顺序一致

结论

<stdatomic.h> 库是C标准库中用于处理多线程环境下数据同步和一致性的强大工具。通过使用这些原子类型、操作和内存顺序，程序员可以编写高效且可靠的并发程序，确保在多线程环境下的数据一致性和同步性。本文详细介绍了 <stdatomic.h> 库的各个功能和用法，并提供了实际应用示例和图表描述，帮助读者深入理解和掌握这些功能。希望本文对读者在C语言编程中的多线程开发有所帮助。