Devo dividere la sincronizzazione dalla mia classe e come si chiama?

Question

Devo dividere la sincronizzazione dalla mia classe e come si chiama?

#1 da (4 voti)
#2 da (2 voti)

3

Quando ho pensato alla testabilità e al codice modulare, ho pensato di recente se dovrei suddividere la parte di sincronizzazione di una classe dalla parte del comportamento reale.

Per esempio:

L'app "ha bisogno" di questo:

class Mogrifier { // Mogrifier accesses are thread safe
private:
  unsigned int m_state;
  mutex m_sync;
public:
  Mogrifier()
  : m_state(0)
  { }

  unsigned int Mutate() {
    lock_guard<mutex> lock(m_sync);
    const unsigned int old = m_state;
    m_state += 42;
    return old;
   }

  :::
};

Sembra abbastanza semplice, tranne il blocco e le cose reali che la classe fa non sono realmente correlate.

Quindi penso che sia una buona idea dividerlo:

class Mogrifier { // Mogrifier is *not* synchronized
private:
  unsigned int m_state;
public:
  Mogrifier()
  : m_state(0)
  { }

  unsigned int Mutate() {
    const unsigned int old = m_state;
    m_state += 42;
    return old;
   }

  :::
};

class SyncedMogrifer {
private:
  mutex m_sync;
  Mogrifier m_;
public:
  unsigned int Mutate() {
    lock_guard<mutex> lock(m_sync);
    return m_.Mutate();
  }
};

Lo faresti?
Aiuterà con il test delle unità?
Sono pessimo con i nomi di Pattern ... come si chiama?
C'è un modo semplice per "generare" un tale wrapper in C ++ per una chiamata arbitraria?

unit-testing c++ design-patterns multithreading

posta Martin Ba 14.02.2013 - 23:54

fonte

2 risposte

Leggi altre domande sui tag unit-testing c++ design-patterns multithreading

Come ottimizzare le chiamate a più API contemporaneamente e tornare come un unico set? Quali sono i tipi di matrici di lingue digitate dinamicamente?

score 4 · Answer 1

Hai davvero bisogno di qualche aiuto da Herb . Lui può dirti come affrontare questo. Cliffnotes:

template<typename T> class Monitor {
    T t;
    std::mutex m;
public:
    template<typename F> auto operator()(F&& f) -> decltype(f(t)) {
        lock_guard<mutex> lock(m);
        return f(t);
    }
};
Monitor<Mogrifier> safe;
safe([](Mogrifier& m) {
    m.mutate();
});

La seconda parte è che non dovresti davvero bloccare , e se lo fai, non puoi farlo su un livello per metodo.

score 2 · Answer 2

Lo farei se avessi altre classi che volevo sincronizzare. Se non lo facessi, direi che è una complessità inutile e il mogrifier sincronizzato mi sta bene così com'è.

Aiuterà con i test delle unità se si desidera testare il codice di sincronizzazione separato dalla funzionalità di Mogrifier e viceversa. Altrimenti, non lo farà. Probabilmente è una buona idea testare il codice di sincronizzazione dato che è molto facile da riempire.

Come per le ultime due domande ... non so :)

(Oh e BTW sono australiano quindi ho intenzione di essere maledettamente sincronizzato con una S e non una Z anche se chrome ha evidenziato tutte le 5 istanze in questa textarea.)