스레드 안전 모드에서 컨테이너를 반복하는 방법은 무엇입니까?

Question

다른 스레드에서 두 가지 방법으로 작동해야하는 컨테이너 (C++)가 있습니다. 1) 요소를 추가 및 제거하고 2) 해당 멤버를 반복합니다. 분명히, 반복이 일어난 동안 요소를 제거 = 재앙.

class A 
{ 
public: 
    ... 
    void AddItem(const T& item, int index) { /*Put item into my_stuff at index*/ } 
    void RemoveItem(const T& item) { /*Take item out of m_stuff*/ } 
    const list<T>& MyStuff() { return my_stuff; } //*Hate* this, but see class C 
private: 
    Mutex mutex; //Goes in the *Item methods, but is largely worthless in MyStuff() 
    list<T> my_stuff; //Just as well a vector or deque 
}; 
extern A a; //defined in the .cpp file 

class B 
{ 
    ... 
    void SomeFunction() { ... a.RemoveItem(item); } 
}; 

class C 
{ 
    ... 
    void IterateOverStuff() 
    { 
     const list<T>& my_stuff(a.MyStuff()); 
     for (list<T>::const_iterator it=my_stuff.begin(); it!=my_stuff.end(); ++it) 
     { 
      ... 
     } 
    } 
}; 

다시 B::SomeFunction() 및 C::IterateOverStuff()가 비동기 적으로 호출 얻고있다 : 코드는 다음과 같이 보입니다. 반복 도중 my_stuff이 추가 또는 제거 작업에서 '보호'되었는지 확인하기 위해 사용할 수있는 데이터 구조는 무엇입니까?

Answer 1

같은 소리는 reader/writer lock입니다. 기본적으로 하나 이상의 독자가 또는 명의 작가가있을 수 있습니다. 동시에 읽기 및 쓰기 잠금을 가질 수 없습니다.

편집 : 디자인에 맞는 사용법의 예는 약간의 변경이 필요합니다. 목록을 소유하고있는 클래스에 "iterate"함수를 추가하고 템플릿으로 만들면 함수/펑터를 전달하여 각 노드에 대해 수행 할 작업을 정의 할 수 있습니다. 이런 식으로 뭔가 (신속하고 더러운 의사 코드,하지만 당신은 요점을 파악 ...) :

class A { 
public: 
    ... 
    void AddItem(const T& item, int index) { 
     rwlock.lock_write(); 
     // add the item 
     rwlock.unlock_write(); 
    } 

    void RemoveItem(const T& item) { 
     rwlock.lock_write(); 
     // remove the item 
     rwlock.unlock_write(); 
    } 

    template <class P> 
    void iterate_list(P pred) { 
     rwlock.lock_read(); 
     std::for_each(my_stuff.begin(), my_stuff.end(), pred); 
     rwlock.unlock_read(); 
    } 

private: 
    rwlock_t rwlock; 
    list<T> my_stuff; //Just as well a vector or deque 
}; 


extern A a; //defined in the .cpp file 

class B { 
    ... 
    void SomeFunction() { ... a.RemoveItem(item); } 
}; 

class C { 
    ... 

    void read_node(const T &element) { ... } 

    void IterateOverStuff() { 
     a.iterate_list(boost::bind(&C::read_node, this)); 
    } 
}; 

또 다른 옵션 리더/라이터 잠금 공개적으로 액세스 할 수 있도록하고 올바르게 사용에 대한 책임 호출을하는 것입니다 자물쇠. 그러나 그것은 오류가 발생하기 쉽습니다.

Answer 2

목록을 반환하면 해당 생성자/소멸자에서 뮤텍스를 잠 그거나 잠금 해제하는 클래스로 묶인 목록을 반환하십시오. 뮤텍스는 재귀하지 않도록

class LockedIterable { 
public: 
    LockedIterable(const list<T> &l, Mutex &mutex) : list_(l), mutex_(mutex) 
    {lock(mutex);} 
    LockedIterable(const LockedIterable &other) : list_(other.list_), mutex_(other.mutex_) { 
    // may be tricky - may be wrap mutex_/list_ in a separate structure and manage it via shared_ptr? 
    } 
    ~LockedIterable(){unlock(mutex);} 
    list<T>::iterator begin(){return list_.begin();} 
    list<T>::iterator end(){return list_.end();} 
private: 
    list<T> &list_; 
    Mutex &mutex_; 
}; 

class A { 
    ... 
    LockedIterable MyStuff() { return LockedIterable(my_stuff, mutex); } 
}; 

까다로운 부분의 라인을 따라 뭔가 복사 생성자를 쓰고있다. 또는 auto_ptr을 사용하십시오.

오, 여기에 뮤텍스보다 리더/라이터 잠금 장치가 더 나은 솔루션입니다.

Answer 3

IMHO 데이터 구조 클래스에 개인 뮤텍스가 있고 클래스 메서드를 작성하여 메서드를 호출하는 코드가 무엇을하든 관계없이 모든 것이 스레드로부터 안전하도록하는 것은 실수입니다. 이것을 완전하고 완벽하게 수행하는 데 필요한 복잡성은 맨 위에 있습니다.

더 간단한 방법은 데이터에 액세스해야 할 때 호출 코드가 잠금을 담당하는 공용 (또는 전역) 뮤텍스를 만드는 것입니다.

Here이 주제에 관한 내 블로그 기사입니다.