Question

我遇到需要跨线程访问共享内存中的变量的情况。该变量最初是在许多地方的现有代码中定义和不断更新的。我添加的代码将允许此现有代码库作为后台线程运行，但我需要从此共享变量中读取数据。

我的问题是，我是否需要在每次更新现有代码库时添加互斥锁？或者，我可以在我读取数据时将新的代码添加到新代码中。我在下面创建了以下小测试用例，似乎是锻炼。

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


typedef struct my_data {

    int shared;

}MY_DATA;

MY_DATA data;
pthread_mutex_t lock;


void *background(void *x_void_ptr)
{
    int i = 0;
    int sleep_time;
    while(i < 10)
    {

        data.shared++;

        printf("BACK thread, Data = %d\n", data.shared);

        sleep_time = rand()%5;
        sleep(sleep_time);
        i++;
    }


    return NULL;

}

int main()
{


    int sleep_time;
    pthread_t bg_thread;


    if(pthread_create(&bg_thread, NULL, background, NULL)) {

        fprintf(stderr, "Error creating thread\n");
        return 1;

    }

    MY_DATA *p_data = &data;

    int i = 0;
    while(i < 10)
    {
        pthread_mutex_lock(&lock);
        printf("FOR thread, Data = %d\n", p_data->shared);


        pthread_mutex_unlock(&lock);
        sleep_time = rand()%5;
        sleep(sleep_time);

        i++;
    }



    // Finish up
    if(pthread_join(bg_thread, NULL)) {

        fprintf(stderr, "Error joining thread\n");
        return 2;

    }


    return 0;

}

输出：

FOR thread, Data = 0
BACK thread, Data = 1
BACK thread, Data = 2
FOR thread, Data = 2
FOR thread, Data = 2
BACK thread, Data = 3
BACK thread, Data = 4
BACK thread, Data = 5
FOR thread, Data = 5
BACK thread, Data = 6
BACK thread, Data = 7
BACK thread, Data = 8
FOR thread, Data = 8
FOR thread, Data = 8
BACK thread, Data = 9
FOR thread, Data = 9
BACK thread, Data = 10
FOR thread, Data = 10
FOR thread, Data = 10
FOR thread, Data = 10

多次运行后，看起来没有数据损坏（即前台正在读取正确的数据），但我的直觉是说我需要在前台代码和后台代码中都使用互斥锁。

Answer 1

^{将材料从我的comment转移到答案中。}

请注意，进程中的所有全局内存（线程局部存储除外，函数中的局部变量除外）在线程之间共享。共享内存是进程间共享内存的术语。

线程或进程是否正在访问内存，只要有多个执行线程可以同时访问同一内存，就需要确保正确管理访问（例如，使用互斥锁）。现在，假设你在一台机器上有一个单独的核心很少是安全的，所以潜在的并发访问是常态。

Answer 2

不，你的记忆不会被破坏，阅读对此没有任何影响。但你会读到一个不一致的状态，这同样糟糕。

如果只有一个线程使用互斥锁，那么线程间的共享内存是否会被破坏？

2 个答案: