如何为数组中的元素锁定互斥锁，而不是为整个数组锁定互斥体

使用原子指针"锁定"内存中某些位置的示例代码：

#include <vector>
#include <atomic>
#include <thread>
using container = std::vector<std::atomic<double>>;
using container_size_type = container::size_type;
container c(300);
std::atomic<container::pointer> p_busy_elem{ nullptr };
void editor()
{
    for (container_size_type i{ 0 }, sz{ c.size() }; i < sz; ++i)
    {
        p_busy_elem.exchange(&c[i]); // c[i] is busy
        // ... edit c[i] ... // E: calculate a value and assign it to c[i]
        p_busy_elem.exchange(nullptr); // c[i] is no longer busy
    }
}
void reader()
{
    for (container_size_type i{ 0 }, sz{ c.size() }; i < sz; ++i)
    {
        // A1: wait for editor thread to finish editing value
        while (p_busy_elem == &c[i])
        {
            // A2: room a better algorithm to prevent blocking/yielding
            std::this_thread::yield();
        }
        // B: if c[i] is updated in between A and B, this will load the latest value
        auto value = c[i].load();
        // C: c[i] might have changed by this time, but we had the most up to date value we could get without checking again
        // ... use value ...
    }
}
int main()
{
    std::thread t_editor{ editor };
    std::thread t_reader{ reader };
    t_editor.join();
    t_reader.join();
}

在编辑器线程中，设置了繁忙指针以指示当前正在编辑该内存位置 (E(。如果线程 B 在设置繁忙指针后尝试读取该值，它将等到编辑完成后再继续 (A1(。

关于A2的说明：可以在这里放置一个更好的系统。可以保留尝试读取时繁忙的节点列表，然后我们将i添加到该列表中，并在以后尝试处理该列表。好处：可以告诉循环执行continue，并且读取超过当前正在编辑i的索引。

创建要读取的值的副本 (B( 以便根据需要使用它 (C(。这是我们最后一次可以在 c[i] 处检查最新值

如果不调整数组大小，则不需要对单个元素或整个数组进行任何互斥锁。

原子地阅读你的价值观，原子地写下你的价值观并保持冷静。

如果您希望在不使用互斥锁的情况下对类似数组的数据结构进行高性能多线程访问，则可以研究比较和交换。也许您可以设计一种适用于您的特定问题的无锁数据结构。https://en.wikipedia.org/wiki/Compare-and-swap

关于发布的代码，您似乎使事情变得过于复杂。如果要实现：

foo1 (first half)
foo2 (first half) and foo1 (second half) (in parallel)
foo1 (first half) and foo2 (second half) (in parallel)
...
foo2(second half)

两个穆特克斯应该可以。

也许这可以做到。下面是一些伪代码：

// These global variables controls which thread is allowed to
// execute first and second half.
// 1 --> Foo1 may run
// 2 --> Foo2 may run
int accessFirstHalf = 1;
int accessSecondHalf = 1;
void foo1 ( data_pointers &data)
{
    while(YOU_LIKE_TO_GO_ON)
    {
        while (true)
        {
            TAKE_MUTEX_FIRST_HALF;
            if (accessFirstHalf == 1)
            {
                RELEASE_MUTEX_FIRST_HALF;
                break;
            }
            RELEASE_MUTEX_FIRST_HALF;
            pthread_yield();
        }
        // Do the first half
        TAKE_MUTEX_FIRST_HALF;
        // Allow Foo2 to do first half
        accessFirstHalf == 2;
        RELEASE_MUTEX_FIRST_HALF;
        while (true)
        {
            TAKE_MUTEX_SECOND_HALF;
            if (accessSecondHalf == 1)
            {
                RELEASE_MUTEX_SECOND_HALF;
                break;
            }
            RELEASE_MUTEX_SECOND_HALF;
            pthread_yield();
        }
        // Do the second half
        TAKE_MUTEX_SECOND_HALF;
        // Allow Foo2 to do second half
        accessSecondHalf == 2;
        RELEASE_MUTEX_SECOND_HALF;
    }
}

void foo2 ( data_pointers &data)
{
    while(YOU_LIKE_TO_GO_ON)
    {
        while (true)
        {
            TAKE_MUTEX_FIRST_HALF;
            if (accessFirstHalf == 2)
            {
                RELEASE_MUTEX_FIRST_HALF;
                break;
            }
            RELEASE_MUTEX_FIRST_HALF;
            pthread_yield();
        }
        // Do the first half
        TAKE_MUTEX_FIRST_HALF;
        // Allow Foo1 to do first half
        accessFirstHalf == 1;
        RELEASE_MUTEX_FIRST_HALF;
        while (true)
        {
            TAKE_MUTEX_SECOND_HALF;
            if (accessSecondHalf == 2)
            {
                RELEASE_MUTEX_SECOND_HALF;
                break;
            }
            RELEASE_MUTEX_SECOND_HALF;
            pthread_yield();
        }
        // Do the second half
        TAKE_MUTEX_SECOND_HALF;
        // Allow Foo1 to do second half
        accessSecondHalf == 1;
        RELEASE_MUTEX_SECOND_HALF;
    }
}

int main()
{
    // start the threads with foo1 and foo2
}

这似乎是您要求的核心：

foo1 (first half)
foo2 (first half) and foo1 (second half) (in parallel)
foo1 (first half) and foo2 (second half) (in parallel)
...
foo2(second half)

实现与 pthreads 交错的最简单方法是使用屏障。

使用 2 count pthread_barrier_init()初始化屏障。 然后foo1()执行：

first half
pthread_barrier_wait()
second half
pthread_barrier_wait()
...
first half
pthread_barrier_wait()
second half
pthread_barrier_wait()

foo2()执行的序列略有不同：

pthread_barrier_wait()
first half
pthread_barrier_wait()
second half
....
pthread_barrier_wait()
first half
pthread_barrier_wait()
second half