是否可以在 C++ 中使用 std::atomic_flag 获得线程锁定机制？答案

【问题标题】：Is possible to get a thread-locking mechanism in C++ with a std::atomic_flag?是否可以在 C++ 中使用 std::atomic_flag 获得线程锁定机制？
【发布时间】：2012-10-10 18:41:18
【问题描述】：

使用 MS Visual C++2012

一个类有一个std::atomic_flag类型的成员

class A {
    public:
    ...
    std::atomic_flag lockFlag;
    A () { std::atomic_flag_clear (&lockFlag); } 
};

有一个A类型的对象

A object;

两个（Boost）线程可以访问谁

void thr1(A* objPtr) { ... }
void thr2(A* objPtr) { ... }

如果对象正在被其他线程访问，想法是等待线程。

问题是：有可能用atomic_flag 对象构建这样的机制吗？暂时不要这么说，我想要一些轻量级的 boost::mutex。

顺便说一下，其中一个线程所涉及的进程是对获得许多行的 dBase 的非常长的查询，我只需要在发生冲突的某个代码区域（处理每一行时）将其挂起，然后我等不及整个线程完成join()。

我已经在每个线程中尝试了一些：

thr1 (A* objPtr) {
    ...
    while (std::atomic_flag_test_and_set_explicit (&objPtr->lockFlag, std::memory_order_acquire)) {
        boost::this_thread::sleep(boost::posix_time::millisec(100));
    }
    ...  /* Zone to portect */

    std::atomic_flag_clear_explicit (&objPtr->lockFlag, std::memory_order_release);
    ...  /* the process continues  */
}

但没有成功，因为第二个线程挂起。其实我并不完全了解atomic_flag_test_and_set_explicit函数所涉及的机制。如果这样的函数立即返回或者可以延迟直到标志可以被锁定，也不会。

对我来说，如何获得具有这样一个函数的锁定机制也是一个谜，该函数总是设置值并返回先前的值。没有选项只能读取实际设置。

欢迎提出任何建议。

【问题讨论】：

您在寻找无锁算法吗？
实际上，您应该只使用互斥锁来保护您想要同步访问的内容。这就是互斥锁的用途。此外，如果您确实希望多个线程同时访问，请使用信号量。
@Tony 我需要进一步了解信号量，但需要互斥体是对象的成员吗？你能在每个线程中发布互斥锁的简短快照吗？
A object(); 是一个函数声明。
GManNickG 好的。好的。已更正。有一个默认的构造函数。其他想法？

标签： c++ boost c++11 boost-thread atomic

【解决方案1】：

顺便说一下，其中一个线程所涉及的进程是对获得许多行的 dBase 的非常长的查询，我只需要在发生冲突的某个代码区域中将其挂起（在处理每一行时) 我等不及整个线程完成 join()。

这样的区域被称为临界区。使用临界区最简单的方法是通过互斥锁定。

建议的互斥解决方案确实是要走的路，除非您可以证明这是一个热点并且锁争用是一个性能问题。 仅使用原子和内在函数的无锁编程非常复杂，在此级别不推荐。

这是一个简单的示例，展示了如何做到这一点（直播于http://liveworkspace.org/code/6af945eda5132a5221db823fa6bde49a）：

#include <iostream>
#include <thread>
#include <mutex>

struct A
{
    std::mutex mux;
    int x;

    A() : x(0) {}
};

void threadf(A* data)
{
    for(int i=0; i<10; ++i)
    {
        std::lock_guard<std::mutex> lock(data->mux);
        data->x++;
    }
}

int main(int argc, const char *argv[])
{
    A instance;
    auto t1 = std::thread(threadf, &instance);
    auto t2 = std::thread(threadf, &instance);

    t1.join();
    t2.join();

    std::cout << instance.x << std::endl;

    return 0;
}

【讨论】：

感谢您的建议和关于关键部分的指示。我会仔细研究这个例子，当我有答案或任何其他问题时会回到这里。

【解决方案2】：

看起来您正在尝试编写自旋锁。是的，您可以使用std::atomic_flag 来做到这一点，但您最好使用std::mutex 来代替。除非你真的知道自己在做什么，否则不要使用原子。

【讨论】：

你是对的。如果我不被我对英语语言的糟糕理解所吸引，那么你确实想要的是一个自旋锁。我读过你的第 5 章？本书“C++ Concurrency in action”，必须承认不完全理解它。我觉得我一开始就缺少一些东西。无论如何，我打算做一些测试；仔细阅读它，作为最后的资源，请遵循建议并使用互斥锁。
Glub。请原谅我之前评论的问号。我写它是为了记住你的名字和这本书的作者之间的一致性。后来我看到了你的个人资料。

【解决方案3】：

要实际回答所提出的问题：是的，您可以使用 std::atomic_flag 创建一个称为自旋锁的线程锁定对象。

#include <atomic>

class atomic_lock
{
    public:
        atomic_lock()
            : lock_( ATOMIC_FLAG_INIT )
        {}

        void lock()
        {
            while ( lock_.test_and_set() ) { } // Spin until the lock is acquired.
        }

        void unlock()
        {
            lock_.clear();
        }

    private:
        std::atomic_flag lock_;
};

【讨论】：