使用 EnterCriticalSection 时出现的问题

Question

我需要使用多个线程中的数组，因此我使用 CRITICAL SECTION 为其提供对数据的独占访问权限。
这是我的模板：

#include "stdafx.h"
#ifndef SHAREDVECTOR_H
#define SHAREDVECTOR_H

#include <vector>
#include <windows.h>

template<class T>
class SharedVector {
    std::vector<T> vect;
    CRITICAL_SECTION cs;
    SharedVector(const SharedVector<T>& rhs) {}
public:
    SharedVector();
    explicit SharedVector(const CRITICAL_SECTION& CS);
    void PushBack(const T& value);
    void PopBack();
    unsigned int size() const;
    T& operator[](int index);
    virtual ~SharedVector();
};

template<class T>
SharedVector<T>::SharedVector() {
    InitializeCriticalSection(&cs);
}

template<class T>
SharedVector<T>::SharedVector(const CRITICAL_SECTION& r): cs(r) {
    InitializeCriticalSection(&cs);
}

template<class T>
void SharedVector<T>::PushBack(const T& value) {
    EnterCriticalSection(&cs);
    vect.push_back(value);
    LeaveCriticalSection(&cs);
}

template<class T>
void SharedVector<T>::PopBack() {
    EnterCriticalSection(&cs);
    vect.pop_back();
    LeaveCriticalSection(&cs);
}

template<class T>
unsigned int SharedVector<T>::size() const {
    EnterCriticalSection(&cs);
    unsigned int result = vect.size();
    LeaveCriticalSection(&cs);
    return result;
}

template<class T>
T& SharedVector<T>::operator[](int index) {
    EnterCriticalSection(&cs);
    T result = vect[index];
    LeaveCriticalSection(&cs);
    return result;
}

template<class T>
SharedVector<T>::~SharedVector() {
    DeleteCriticalSection(&cs);
}

编译时，我在调用 EnterCriticalSection(&cs) 和 LeaveCriticalSection(&cs) 时遇到这样的问题：

'EnterCriticalSection' : cannot convert parameter 1 from 
'const CRITICAL_SECTION *' to 'LPCRITICAL_SECTION'

我不知道是什么是错的。 也许你能看到。 因为我一直都是这么用的，而且还好。 包含 windows.h

Answer 1

只需将 cs 声明为：

mutable CRITICAL_SECTION cs;

或者删除 size() 上的 const 子句。

进入临界区会修改 CRITICAL_SECTION，离开则会再次修改它。 由于进入和离开关键部分不会使 size() 方法调用在逻辑上成为非 const，因此我建议将其声明为 const >，并使 cs 可变。 mutable 正是针对这种情况而引入的。

另外 - 看看 Martin York 和 Joe Mucchiello 的建议 - 尽可能使用 RAII 来处理需要清理的任何类型的资源。 这对于关键部分和指针和文件句柄一样有效。

Answer 2

另外上面的代码不是异常安全的。
不保证push_back() pop_back()不会抛出异常。 如果他们这样做，他们将使您的关键部分永久锁定。 您应该创建一个储物柜类，在构造时调用 EnterCriticalSection()，在销毁时调用 LeaveCriticalSection()。

这也使得你的方法更容易阅读。 （见下文）

class CriticalSectionLock
{
    public:
        CriticalSectionLock(CRITICAL_SECTION& cs)
            : criticalSection(cs)
        {
            EnterCriticalSection(&criticalSection);
        }
        ~CriticalSectionLock()
        {
            LeaveCriticalSection(&criticalSection);
        }
    private:
        CRITICAL_SECTION&  criticalSection;
};


// Usage
template
unsigned int SharedVector::size() const
{
    CriticalSectionLock  lock(cs);
    return vect.size();
}

您应该担心的另一件事。 确保当您销毁该对象时您拥有所有权，并且在销毁期间没有其他人试图获得所有权。 希望您的 DestoryCriticalSection() 能够解决这个问题。

Answer 3

我更喜欢使用单独的 Acquisition 对象而不是代码。 当 Enter 和 Leave 调用之间发生异常时，您的代码如果很脆弱：

class CS_Acquire {
    CRITICAL_SECTION &cs;
public:
    CS_Acquire(CRITICAL_SECTION& _cs) : cs(_cs) { EnterCriticalSection(cs); }
    ~CS_Acquire() { LeaveCriticalSection(cs); }
};

那么在您的类方法中，您将其编码为：

template <typename T>
void SharedVector::PushBack(const T& value) {
   CS_Acquire acquire(&cs);
   vect.push_back(value);
}

Answer 4

EnterCriticalSection 不接受 const 参数。 顺便说一句，这是一个编译错误，而不是链接错误...

另外，您确定要将关键部分传递到您的构造函数中，然后让该构造函数执行 InitializeCriticalSection 调用吗？ 如果你想共享你的关键部分，我想你应该先初始化它，然后再分发它。

Answer 5

我看到您声明了一个空的复制构造函数：

SharedVector(const SharedVector& rhs) {}

我确信您知道，这个函数什么也不做，而且它还使 cs 未初始化。 由于您的类包含 CRITICAL_SECTION 的实例，因此您必须确保禁止复制构造函数和赋值运算符调用，除非您要完全实现它们。 您可以通过在类的 private 部分中放置以下声明来实现此目的：

SharedVector(const SharedVector &);
SharedVector &operator=(const SharedVector &);

这可以防止编译器自动生成这些方法的错误版本，也可以防止您在编写的其他代码中调用它们（因为这些只是声明，而不是带有 {} 代码块的定义）。

另外，正如 Arnout 提到的，采用 CRITICAL_SECTION& 的构造函数论证似乎是错误的。 您的实现所做的是将传入的关键部分复制到 cs （这对于 CRITICAL_SECTION 来说不是有效的操作），然后调用 InitializeCriticalSection(& ;cs) 它会覆盖您刚刚所做的副本并创建一个新的关键部分。 对于传入关键部分的调用者来说，这似乎通过有效地忽略传入的内容而做了错误的事情。

Answer 6

所以，访问权限有问题。
我将 size() 方法设置为非常量，现在可以了。