Question

我有一个多线程科学应用程序，其中几个计算线程（每个核心一个）必须将其结果存储在公共缓冲区中。这需要一个互斥机制。

工作线程只花费一小部分时间写入缓冲区，因此互斥锁在大多数时间都处于解锁状态，并且锁定很有可能立即成功而无需等待另一个线程解锁。

目前，我已经使用Qt的QMutex来完成任务，并且效果很好：互斥锁的开销可以忽略不计。

但是，我必须将它移植到c ++ 11 / STL。使用std :: mutex时，性能下降了66％，并且线程花费大部分时间来锁定互斥锁。

在另一个问题之后，我认为Qt使用基于简单原子标志的快速锁定机制，针对互斥锁尚未锁定的情况进行了优化。并发锁定时会回退到系统互斥锁。

我想在STL中实现这一点。是否有一种基于std :: atomic和std :: mutex的简单方法？我已经深入研究了Qt的代码，但是我的使用似乎过于复杂（我不需要锁定超时，pimpl，小占用空间等......）。

编辑：我尝试了一个自旋锁，但是效果不好，因为：

定期（每隔几秒），另一个线程锁定互斥锁并刷新缓冲区。这需要一些时间，因此此时所有工作线程都会被阻止。自旋锁使调度繁忙，导致刷新比使用适当的互斥锁慢10-100倍。这是不可接受的

编辑：我试过这个，但它无效（锁定所有线程）

class Mutex
{
public:
    Mutex() : lockCounter(0) { }

    void lock()
    {
        if(lockCounter.fetch_add(1, std::memory_order_acquire)>0)
        {
            std::unique_lock<std::mutex> lock(internalMutex);
            cv.wait(lock);
        }
    }

    void unlock();
    {
        if(lockCounter.fetch_sub(1, std::memory_order_release)>1)
        {
            cv.notify_one();
        }
    }


private:
    std::atomic<int> lockCounter;
    std::mutex internalMutex;
    std::condition_variable cv;
};

谢谢！

编辑：最终解决方案

MikeMB的快速互斥体运行良好。

作为最终解决方案，我做了：

使用带有try_lock
当一个线程无法try_lock，而不是等待时，它们会填充一个队列（不与其他线程共享）并继续
当线程获得锁定时，它会使用当前结果更新缓冲区，但也会将结果存储在队列中（它会处理其队列）
缓冲区冲洗效率更高：阻塞部分只交换两个指针。

Answer 1

一般建议

正如一些评论中所提到的，我首先要看一下，您是否可以重新构建程序设计，以使互斥锁实现对您的性能不那么重要。
此外，由于标准c ++中的多线程支持是相当新的并且有点幼稚，因此有时您不得不依赖于特定于平台的机制，例如Linux系统上的futex或Windows上的关键部分或Qt等非标准库话虽这么说，我可以想到两种可能会加速你的程序的实现方法：

<强>螺旋锁
如果访问冲突很少发生，并且互斥锁只能保持很短的时间（当然应该努力实现两件事），使用自旋锁可能是最有效的，因为它不需要任何系统完全调用并且实现起来很简单（取自cppreference）：

class SpinLock {
    std::atomic_flag locked ;
public:
    void lock() {
        while (locked.test_and_set(std::memory_order_acquire)) { 
             std::this_thread::yield(); //<- this is not in the source but might improve performance. 
        }
    }
    void unlock() {
        locked.clear(std::memory_order_release);
    }
};

缺点当然是等待线程不能保持睡眠状态并且不会浪费处理时间。

已检查锁定

这基本上是你演示的想法：你首先要快速检查，是否实际上需要基于原子交换操作进行锁定，并且只有在不可避免的情况下才使用重std::mutex。

struct FastMux {
    //Status of the fast mutex
    std::atomic<bool> locked;
    //helper mutex and vc on which threads can wait in case of collision
    std::mutex mux;
    std::condition_variable cv;
    //the maximum number of threads that might be waiting on the cv (conservative estimation)
    std::atomic<int> cntr; 

    FastMux():locked(false), cntr(0){}

    void lock() {
        if (locked.exchange(true)) {
            cntr++;
            {
                std::unique_lock<std::mutex> ul(mux);
                cv.wait(ul, [&]{return !locked.exchange(true); });
            }
            cntr--;
        }
    }
    void unlock() {
        locked = false;
        if (cntr > 0){
            std::lock_guard<std::mutex> ul(mux);
            cv.notify_one();
        }
    }
};

请注意，std::mutex并未锁定在lock()和unlock()之间，但它仅用于处理条件变量。如果互斥锁上存在高拥塞，则会导致更多的锁定/解锁调用。

您的实施问题是，cv.notify_one();和if(lockCounter.fetch_add(1, std::memory_order_acquire)>0)之间可能会调用cv.wait(lock);，因此您的线程可能永远不会被唤醒。

我没有对您提议的实施的固定版本进行任何性能比较，但您只需要看看哪种方式最适合您。

Answer 2

根据定义并非真正的答案，但根据具体任务，无锁队列可能有助于摆脱互斥锁。如果您有多个生产者和一个消费者（甚至多个消费者），这将有助于设计。链接：

虽然不是直接使用C ++ / STL，但Boost.Lockfree提供了这样的队列。
另一种选择是＆＃34; C ++ Concurrency in Action＆＃34;中的无锁队列实现。安东尼威廉姆斯。
A Fast Lock-Free Queue for C++

更新 wrt到评论：

队列大小/溢出：

队列溢出可以通过以下方式避免：i）使队列足够大或ii）通过在队列满了后使生产者线程等待推送数据。
另一个选择是使用多个使用者和多个队列并实现并行缩减，但这取决于数据的处理方式。

消费者主题：

队列可以使用std::condition_variable并使消费者线程等到有数据。
另一种选择是使用定时器来检查队列非空的定期间隔（轮询），一旦非空，线程可以连续获取数据并返回等待模式。

实现类似于Qt的高性能互斥锁

2 个答案: