c++ - 在并发数据结构中，什么级别的锁定粒度是好的？

Question

我对多线程很陌生，我有一个单线程数据分析应用程序，它具有很好的并行化潜力，虽然数据集很大，但它不会接近硬盘读/写饱和所以我想我应该利用现在标准中的线程支持并尝试加快这头野兽的速度。

经过一些研究后，我认为生产者消费者是从磁盘读取数据并进行处理的好方法，我开始编写一个对象池，该对象池将成为循环缓冲区的一部分，生产者将在其中放置数据和消费者获取数据。在我编写类(class)时，感觉我在处理锁定和释放数据成员的方式上过于细化了。感觉一半的代码都在锁定和解锁，并且好像有大量的同步对象在四处漂浮。

所以我带着一个类声明和一个示例函数来找你，还有这个问题:这是否太细粒度了？粒度不够细？考虑不周？

struct PoolArray
{
public:
    Obj* arr;
    uint32 used;
    uint32 refs;
    std::mutex locker;
};

class SegmentedPool
{
public: /*Construction and destruction cut out*/
    void alloc(uint32 cellsNeeded, PoolPtr& ptr);
    void dealloc(PoolPtr& ptr);
    void clearAll();
private:
    void expand();

    //stores all the segments of the pool
    std::vector< PoolArray<Obj> > pools;
    ReadWriteLock poolLock;

    //stores pools that are empty
    std::queue< int > freePools;
    std::mutex freeLock;

    int currentPool;
    ReadWriteLock currentLock;
};

void SegmentedPool::dealloc(PoolPtr& ptr)
{
    //find and access the segment
    poolLock.lockForRead();
    PoolArray* temp = &(pools[ptr.getSeg()]);
    poolLock.unlockForRead();
    //reduce the count of references in the segment
    temp->locker.lock();
    --(temp->refs);
    //if the number of references is now zero then set the segment back to unused
    //and push it onto the queue of empty segments so that it can be reused
    if(temp->refs==0)
    {
        temp->used=0;
        freeLock.lock();
        freePools.push(ptr.getSeg());
        freeLock.unlock();
    }
    temp->locker.unlock();
    ptr.set(NULL,-1);
}

一些解释:第一个 PoolPtr 是一个类似于对象的愚蠢的小指针，它存储指针和指针来自的池中的段号。

其次，这都是“模板化”的，但我删除了这些行以尝试减少代码块的长度

第三个 ReadWriteLock 是我使用互斥锁和一对条件变量放在一起的东西。

Answer 1

无论粒度多么细，锁都是低效的，所以要不惜一切代价避免。

队列和 vector 都可以使用compare-swap原语轻松实现无锁。

有很多关于这个主题的论文

无锁队列:

• http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.53.8674&rep=rep1&type=pdf
• http://www.par.univie.ac.at/project/peppher/publications/Published/opodis10lfq.pdf

锁定自由 vector :

• http://www.stroustrup.com/lock-free-vector.pdf

Straustrup 的论文也提到了无锁分配器，但不要马上跳过去，标准分配器现在已经很不错了。

UPD如果您不想费心编写自己的容器，请使用英特尔的线程构建 block 库，它同时提供线程安全 vector 和队列。它们不是无锁的，但它们经过优化可以有效地使用 CPU 缓存。

UPD关于 PoolArray，您在那里也不需要锁。如果您可以使用 c++11，请使用 std::atomic 进行原子增量和交换，否则使用编译器内置函数(MSVC 中的 InterLocked* 函数和 _sync*在海合会中 http://gcc.gnu.org/onlinedocs/gcc-4.1.1/gcc/Atomic-Builtins.html )