在并发数据结构中，什么级别的锁定粒度比较好？

Question

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

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

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

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);
}

几个解释： First PoolPtr 是一个愚蠢的小指针对象，它存储指针和指针来自的池中的段号。

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

第三个 ReadWriteLock 是我使用互斥锁和一对条件变量组合而成的。

Answer 1

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

队列和向量都可以使用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

无锁矢量：

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

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

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

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

Answer 2

一个好的开始 - 您可以在需要时锁定并在完成后立即释放它们。

您的 ReadWriteLock 几乎是一个 CCriticalSection 对象 - 根据您的需要，使用它可能会提高性能。

我要说的一件事是，在释放池 poolLock.unlockForRead(); 上的锁之前调用 temp->locker.lock(); 函数，否则当池对象不受同步控制时，您正在对池对象执行操作 - 它可能正在被使用在那一点上由另一个线程。一个小问题，但对于多线程来说，最终让你失望的是小问题。

采用多线程的一个好方法是将任何受控资源包装在对象或函数中，这些对象或函数在它们内部进行锁定和解锁，因此任何想要访问数据的人都不必担心要锁定哪个锁或解锁，以及何时解锁。例如：

  ...
  if(temp->refs==0)
  {
    temp->used=0;
    freeLock.lock();
    freePools.push(ptr.getSeg());
    freeLock.unlock();
  }
  ...

会...

  ...
  if(temp->refs==0)
  {
    temp->used=0;
    addFreePool(ptr.getSeg());
  }
  ...

void SegmentedPool::addFreePool(unsigned int seg)
{
  freeLock.lock();
  freePools.push(seg);
  freeLock.unlock();
}

也有很多多线程基准测试工具。您可以尝试以不同的方式控制您的资源，通过其中一种工具运行它，如果您觉得性能正在成为问题，则可以查看瓶颈在哪里。