在这种情况下，有什么正确的方法可以实现锁定吗?

我有一个对象数组，我想在线程中操作，但有时我也希望能够访问。这感觉像是实现我的目标的黑客方法，但是有没有更好的方法来做这样的事情？：
*基本目标是有2把锁。一个允许所有单个线程并发工作，同时阻止来自数组的访问，直到它们全部完成，另一个允许关闭来自线程的访问，以确保在函数运行时没有对象被其他线程接触。

atomic<int> inThreadCount;
atomic<int> arrayLock;
map<string, MyObj*> myMap;
mutex mu1;
class MyObj{
mutex mu2;
int myInt;
public: 
void update(bool shouldLowerCount){
mu2.lock();
myInt++;
if (shouldLowerCount)
inThreadCount--;
mu2.unlock();
}
}
//Some operation that requires all threads to finish first
//and doesn't allow threads to access the objects while running
void GetSnapshot(){ 
mu1.lock();
arrayLock++;
while (inThreadCount > 0)
Sleep(0);
map<string, MyObj *>::iterator it = myMap.begin();
auto t = time(nullptr);
auto tm = *localtime(&t);
cout << put_time(&tm, "%d-%m-%Y %H-%M-%S") << endl;
for( ; it != myMap.end(); ++it){
cout << it->first << ":" << it->second->counter);
}
arrayLock--;
mu1.unlock();
}
void updateObject(MyObj* myObj){
while (arrayLock > 0)
Sleep(0);
inThreadCount++;
async(std::launch::async, myObj->update(true));
}

PS，我意识到在 Sleep(( 和 arrayLock/inThreadCount++ 之间有一个很小的错误机会窗口。这是我想解决的问题的一部分！