4

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

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

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

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 是我使用互斥锁和一对条件变量组合而成的。

4

2 回答 2

3

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

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

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

无锁队列：

无锁矢量：

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

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

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

于 2012-12-06T08:51:33.863 回答
1

一个好的开始——你在需要的时候锁定东西，一旦你完成就释放它们。

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

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

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

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

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

于 2012-12-06T09:12:38.577 回答