Проблемы с использованием EnterCriticalSection

Question

Мне нужно работать с массивом из нескольких потоков, поэтому я использую КРИТИЧЕСКИЙ РАЗДЕЛ, чтобы предоставить ему эксклюзивный доступ к данным.
Вот мой шаблон:

#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;

или удалите условие const из size()

Вход в критический раздел изменяет CRITICAL_SECTION, а выход изменяет его снова. Поскольку вход в критический раздел и выход из него не делает логический вызов метода size() логически не const, я бы сказал, что оставьте его объявленным const, и сделайте cs mutable. Это тип ситуации, для которой была введена 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

Я вижу, вы объявили пустой конструктор копирования:

SharedVector(const SharedVector& rhs) {}

Как я уверен, вы знаете, что эта функция ничего не делает, и она также не инициализирует cs. Поскольку ваш класс содержит экземпляр CRITICAL_SECTION, вы должны обязательно запретить вызовы конструктора копирования и вызовов операторов присваивания, если только вы не собираетесь полностью их реализовать. Вы можете сделать это, разместив следующие объявления в разделе private вашего класса:

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

Это не позволяет компилятору автоматически генерировать неправильные версии этих методов, а также не позволяет вам вызывать их в другом коде, который вы пишете (потому что это только объявления, но не определения с {} блоками кода).

Кроме того, как упоминал Арно , конструктор, принимающий аргумент CRITICAL_SECTION&, кажется неправильным. Ваша реализация выполняет копирование переданного критического раздела в cs (что недопустимо для CRITICAL_SECTION), затем вызывает InitializeCriticalSection(&cs), который перезаписывает только что сделанную копию и создает новый критический раздел. Для вызывающего абонента, который прошел в критической секции, это, кажется, делает неправильную вещь, фактически игнорируя все, что было передано.

Answer 5

EnterCriticalSection не принимает аргумент const . Это ошибка компиляции, кстати, а не ошибка компоновки ...

Кроме того, вы уверены, что хотите передать критическую секцию в свой ctor, и затем ctor выполняет вызов InitializeCriticalSection? Если вы хотите поделиться своим критическим разделом, я полагаю, вы сначала инициализируете его, а затем раздаете.

Answer 6

так что с правами доступа что-то не так. Я сделал метод size () неконстантным, и теперь он в порядке.