Własna implementacja RAII C++ dla blokad mutex o ustalonym zakresie

Question

Nie mogę używać boost lub najnowszej biblioteki std :: thread. Najprościej jest stworzyć niestandardową implementację mutex o ustalonym zakresie.

W kilku słowach, gdy instancja klasy tworzy blokadę mutex. Po zniszczeniu klasy muteks zostaje odblokowany.

Jakieś wdrożenie jest dostępne? Nie chcę ponownie wymyślać koła.

Potrzebuję użyć pthreads. Przejęcie zasobów

• jest inicjalizacji == „RAII”

Answer 1

Uwaga To jest stara odpowiedź. C++ 11 zawiera lepszych pomocników, które są bardziej niezależne od platformy:

• std::lock_guard
• std::mutex, std::timed_mutex, std::recursive_mutex, std::recursive_timed_mutex

i inne opcje, takie jak std :: unique_lock, boost :: unique_lock

Każdy kursor RAII zrobi.

Oto sedno: (także na http://ideone.com/kkB86)

// stub mutex_t: implement this for your operating system 
struct mutex_t 
{ 
    void Acquire() {} 
    void Release() {} 
}; 

struct LockGuard 
{ 
    LockGuard(mutex_t& mutex) : _ref(mutex) 
    { 
     _ref.Acquire(); // TODO operating system specific 
    }; 

    ~LockGuard() 
    { 
      _ref.Release(); // TODO operating system specific 
    } 
    private: 
    LockGuard(const LockGuard&); // or use c++0x ` = delete` 

    mutex_t& _ref; 
}; 

int main() 
{ 
    mutex_t mtx; 

    { 
     LockGuard lock(mtx); 
     // LockGuard copy(lock); // ERROR: constructor private 
     // lock = LockGuard(mtx);// ERROR: no default assignment operator 
    } 

} 

Oczywiście można zrobić to generic kierunku mutex_t, można zapobiec podklasy. Kopiowanie/cesja jest już zakazana ze względu na polu odniesienia

EDIT Dla pthreads:

struct mutex_t 
{ 
    public: 
     mutex_t(pthread_mutex_t &lock) : m_mutex(lock) {} 

     void Acquire() { pthread_mutex_lock(&m_mutex); } 
     void Release() { pthread_mutex_unlock(&m_mutex); } 
    private: 
     pthread_mutex_t& m_mutex; 
};