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

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

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

因此，我向您介绍了一个类声明和一个示例函数，以及这个问题：这是否过于细粒度？粒度不够细？考虑不周？

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是一个愚蠢的类似指针的小对象，它将指针和指针所在池中的段号存储起来。

第二，这都是"模板化的"，但我去掉了这些行，试图减少代码块的长度

第三个读写锁是我用互斥锁和一对条件变量组合在一起的。