我有一个多线程应用程序，其中多个线程访问同一个变量-指向一个指针。* volatile * 不会用于确保原子访问（* 不存在 *），而是确保编译不会因为认为一个线程不能影响线程2而进行硬优化，并说 * 没有办法改变... *。
我已经看到了几个 * volatile是无用的 * 在多线程应用程序的职位。我有一个链表，可以在2线程中访问。有效地执行以下操作：
线程1

• 为结构分配内存
• 将线程放入链表
• 处理链表并检查某个值是否设置为xyz

线程2

• 读取链表
• 做一些处理
• 将值设置为xyz

对链表的所有操作都受到系统互斥体（FreeRTOS）的保护，但这并不能确保线程2从开始链表指针看到与线程1相同的值。
在我看来，代码中有2关键部分：

• 线程从list_starts指针看到什么
• 线程在指针内的e->data值中看到什么

这是代码，这是做错了-这是一个参考代码，不用于生产。

#include <stdint.h>
#include <stdlib.h>
#include <stdatomic.h>

typedef struct mytype {
    struct mytype* next;
    int data;
} mytype_t;
typedef _Atomic mytype_t mytype_atomic_t;

mytype_t* list_starts;
//mytype_atomic_t* list_starts;

void
thread1() {
    //Start thread2 here...
    //start_thread(thread2);

    //Run the thread here...
    while (1) {
        //mutex_lock();
        /* Create the entry */
        mytype_t* entry = malloc(sizeof(*entry));
        if (entry != NULL) {
            entry->next = list_starts;
            list_starts = entry;
        }
        //mutex_unlock();
        
        //mutex_lock();
start_over:
        for (mytype_t* e = list_starts, *prev = NULL; e != NULL; prev = e, e = e->next) {
            //mutex_unlock();
            //Simply wait to become 3
            while (e->data != 3) {}
            //mutex_lock();

            //Remove from the list
            if (prev == NULL) {
                list_starts = e->next;
            } else {
                prev->next = e->next;
            }
            free(e);
            goto start_over;
        }
        //mutex_unlock();
    }
}

Godbolt与-mcpu=cortex-m4 -O2产生：https://godbolt.org/z/T84K3x3G4

thread1:
        push    {r4, lr}
        ldr     r4, .L12
.L4:
        movs    r0, #8
        bl      malloc
        cbz     r0, .L2
        ldr     r3, [r4]
        str     r3, [r0]
.L6:
        //Critical part - loaded once
        ldr     r3, [r0, #4]
.L5:
        //Comparison and BNE between self -> no reload
        cmp     r3, #3
        bne     .L5
        ldr     r3, [r0]
        str     r3, [r4]
        bl      free
        ldr     r0, [r4]
        cmp     r0, #0
        bne     .L6
        b       .L4
.L2:
        ldr     r0, [r4]
        cmp     r0, #0
        beq     .L4
        b       .L6
.L12:
        .word   .LANCHOR0
list_starts:

如果我们通过在for循环中使用mytype_atomic_t*类型来更改原始代码，如下所示

for (mytype_atomic_t* e = list_starts, *prev = NULL; e != NULL; prev = e, e = e->next) {
    while (e->data != 3) {}
}

然后godbolt产生：https://godbolt.org/z/94an17x1G

thread1:
        push    {r3, r4, r5, lr}
        ldr     r4, .L13
        ldr     r5, [r4]
.L4:
        movs    r0, #8
        bl      malloc
        cbz     r0, .L2
        str     r5, [r0]
        str     r0, [r4]
.L6:
        adds    r2, r0, #4
.L5:
        //Barrier
        dmb     ish
        //Load first...
        ldr     r3, [r2]
        dmb     ish
        cmp     r3, #3
        //Jump back to pre-load
        bne     .L5
        dmb     ish
        ldr     r3, [r0]
        dmb     ish
        str     r3, [r4]
        bl      free
        ldr     r0, [r4]
        cmp     r0, #0
        bne     .L6
.L7:
        movs    r5, #0
        b       .L4
.L2:
        cmp     r5, #0
        beq     .L7
        mov     r0, r5
        b       .L6
.L13:
        .word   .LANCHOR0
list_starts:

最后的问题-是否足够简单：

• 使用_Atomic关键字声明自定义类型？
• 在这种情况下不要使用 * volatile *？