Bezpieczeństwo gwintów pojedynczej zmiennej

Question

Rozumiem koncepcję bezpieczeństwa gwintów. Szukam porady, aby uprościć bezpieczeństwo wątków, próbując chronić pojedynczą zmienną.

Say mam zmienną:

double aPass; 

i chcę chronić tę zmienną, więc tworzę mutex:

pthread_mutex_t aPass_lock; 

Teraz istnieją dwa dobre sposoby mogę myśleć w ten sposób ale obaj mają denerwujące wady. Pierwszym jest stworzenie bezpiecznego klasę gwintu posiadać zmienną:

class aPass { 
    public: 
     aPass() { 
      pthread_mutex_init(&aPass_lock, NULL); 
      aPass_ = 0; 
     } 

     void get(double & setMe) { 
      pthread_mutex_lock(aPass_lock); 
      setMe = aPass_ 
      pthread_mutex_unlock(aPass_lock); 
     } 

     void set(const double setThis) { 
      pthread_mutex_lock(aPass_lock); 
      aPass_ = setThis; 
      pthread_mutex_unlock(aPass_lock); 
     } 
    private: 
     double aPass_; 
     pthread_mutex_t aPass_lock; 
}; 

Teraz będzie to zachować aPass całkowicie bezpieczny, nic nie może się mylić i nigdy go dotknąć, yay! jednak spójrz na cały ten bałagan i wyobraź sobie zamieszanie podczas uzyskiwania dostępu do niego. obrzydliwy.

Innym sposobem jest uzyskanie dostępu do obu tych funkcji i upewnienie się, że blokujesz muteks przed użyciem aPass.

Ale co, jeśli ktoś nowy przyjdzie na projekt, a jeśli zapomnisz jeden raz, aby go zablokować. Nie lubię debugowania problemów z wątkami, które są trudne.

Czy istnieje dobry sposób na (przy użyciu pthreads, ponieważ muszę używać QNX, który ma mało wsparcia doładowania) Aby zablokować pojedyncze zmienne bez potrzeby dużej klasy, a to jest bezpieczniejsze, to po prostu tworzenie blokady mutex, aby przejść z nim?

Answer 1

Aby rozwinąć moje rozwiązanie, byłoby to coś takiego.

template <typename ThreadSafeDataType> 
class ThreadSafeData{ 
    //.... 
private: 
    ThreadSafeDataType data; 
    mutex mut; 
}; 

class apass:public ThreadSafeData<int> 

Dodatkowo, aby było wyjątkowe, najlepiej byłoby uczynić wszystkich operatorów i członków statycznymi. Aby to zadziałało trzeba użyć CRTP tj

template <typename ThreadSafeDataType,class DerivedDataClass> 
class ThreadSafeData{ 
//.... 
}; 
class apass:public ThreadSafeData<int,apass> 

Answer 2

Możesz utworzyć klasę, która będzie działać jako rodzajowy wrapper wokół zmiennej, synchronizując dostęp do niej.

Dodaj operatora przeciążającego dla zadania i gotowe.

Answer 3

Rozważmy używać RAII idiom poniżej kod to tylko pomysł, to nie przetestowane:

template<typename T, typename U> 
struct APassHelper : boost::noncoypable 
{ 
    APassHelper(T&v) : v_(v) { 
    pthread_mutex_lock(mutex_); 
    } 
    ~APassHelper() { 
    pthread_mutex_unlock(mutex_); 
    } 
    UpdateAPass(T t){ 
    v_ = t; 
    } 
private: 
    T& v_; 
    U& mutex_; 
}; 

double aPass; 
int baPass_lock; 
APassHelper<aPass,aPass_lock) temp; 
temp.UpdateAPass(10); 

Answer 4

Można łatwo tworzyć własne klasy, która blokuje mutex na budowie i odblokowuje go podczas destrukcji. W ten sposób, niezależnie od tego, co się stanie, muteks zostanie zwolniony przy powrocie, nawet jeśli zostanie zgłoszony wyjątek lub jakakolwiek ścieżka zostanie podjęta.

class MutexGuard 
{ 
    MutexType & m_Mutex; 
public: 

    inline MutexGuard(MutexType & mutex) 
     : m_Mutex(mutex) 
    { 
     m_Mutex.lock(); 
    }; 

    inline ~MutexGuard() 
    { 
     m_Mutex.unlock(); 
    }; 
} 


class TestClass 
{ 
    MutexType m_Mutex; 
    double m_SharedVar; 

    public: 
     TestClass() 
      : m_SharedVar(4.0) 
     { } 

     static void Function1() 
     { 
      MutexGuard scopedLock(m_Mutex); //lock the mutex 
      m_SharedVar+= 2345; 
      //mutex automatically unlocked 
     } 
     static void Function2() 
     { 
      MutexGuard scopedLock(m_Mutex); //lock the mutex 
      m_SharedVar*= 234; 
      throw std::runtime_error("Mutex automatically unlocked"); 
     } 

} 

Zmienna m_SharedVar zapewniona jest wzajemne wykluczanie pomiędzy Function1() i Function2() i będzie zawsze odblokowany po powrocie.

boost ma wbudowane typy, aby to osiągnąć: boost :: scoped_locked, boost :: lock_guard.

Answer 5

Możesz modyfikować swoją klasę aPass za pomocą operatorów zamiast get/set:

class aPass { 
public: 
    aPass() { 
     pthread_mutex_init(&aPass_lock, NULL); 
     aPass_ = 0; 
    } 

    operator double() const { 
     double setMe; 
     pthread_mutex_lock(aPass_lock); 
     setMe = aPass_; 
     pthread_mutex_unlock(aPass_lock); 
     return setMe; 
    } 

    aPass& operator = (double setThis) { 
     pthread_mutex_lock(aPass_lock); 
     aPass_ = setThis; 
     pthread_mutex_unlock(aPass_lock); 
     return *this; 
    } 
private: 
    double aPass_; 
    pthread_mutex_t aPass_lock; 
}; 

Zastosowanie:

aPass a; 
a = 0.5; 
double b = a; 

Może to być oczywiście matrycy w celu wsparcia innych rodzajów. Należy jednak pamiętać, że muteks w tym przypadku jest przesadny. Ogólnie rzecz biorąc, bariery pamięciowe wystarczają, gdy chronimy ładunki i magazyny małych typów danych. Jeśli to możliwe, powinieneś użyć C++ 11 std::atomic<double>.

Answer 6

std::atomic<double> aPass; 

pod warunkiem, że masz C++ 11.