Comment utiliser un std::mutex dans une classe de contexte

j'ai un peu de mal à l'aide de C++11 std::mutex

dans ma classe j'ai une variable appelé sémaphore de type std::mutex.

J'ai donc placé mon sémaphore.lock() et un sémaphore.unlock() avant et après ma section critique

class Database {
public:
Database(string, string, string, string);
virtual ~Database();

struct sMyHome getMyHome(void);
struct sPhysical getPhysical(int);
struct sSystemInfo getSystemInfo(void);
void commitSystemInfo(struct sSystemInfo);
struct sTSensors getTSensors(int);
struct sWireless getWireless(int);
struct sWirelessConf getWirelessConf(int);
struct sWirelessStatus getWirelessStatus(int);

private:
void queryMyHome(void);
void queryPhysical(int);
void querySystemInfo(void);
void queryTSensors(int ID);
void queryWireless(int ID);
void queryWirelessConf(int ID);
void queryWirelessStatus(int ID);
string toString(int);

struct sMyHome MyHome;
struct sPhysical Physical[4];
struct sSystemInfo SystemInfo;
struct sTSensors TSensors[32];
struct sWireless Wireless[64];
struct sWirelessConf WirelessConf[64];
struct sWirelessStatus WirelessStatus[64];

MYSQL *connection;
mutex semaphore;
};

c'est une partie du principal, où j'ai récupérer le message d'erreur:

 Database db = Database("192.168.1.10", "****", "******", "******");

mais le cross-compilateur dit 

../main.cpp:8:73: error: use of deleted function 'Database::Database(const Database&)'
  Database db = Database("192.168.1.10", "root", "raspberry", "DomoHome2");
                                                                     ^
In file included from ../main.cpp:2:0:
../Database.h:79:7: note: 'Database::Database(const Database&)' is implicitly deleted      because the default definition would be ill-formed:
 class Database {
   ^
../Database.h:79:7: error: use of deleted function 'std::mutex::mutex(const std::mutex&)'
 In file included from ../Database.h:12:0,
             from ../main.cpp:2:
/Volumes/rpi-crosscompiler-toolchain/arm-none-linux-gnueabi/arm-none-linux-gnueabi/include/c++/4.8.2/mutex:128:5: error: declared here
 mutex(const mutex&) = delete;
 ^
make: *** [main.o] Error 1

et c'est mon constructeur:

Database::Database(string Address, string Username, string Password, string Database) {
//TODO Auto-generated constructor stub
connection = mysql_init(NULL);
mysql_real_connect(connection, Address.c_str(), Username.c_str(), Password.c_str(), Database.c_str(), 0, NULL, 0);
}
  • Vous essayez de copier Database objet, mais elle est non-copiable. Sans doute parce qu'il a un mutex membre de données. Je ne vois pas pourquoi le mutex doit être statique BTW.
  • Vous n'êtes pas fournir assez de votre code. Vos messages d'erreur sont impossibles à interpréter, à moins de fournir plus de code.
  • Vous n'êtes pas montrer le code, et c'est un problème dans le votre code (vérifier celui-ci). Mais de toute façon vérifier les différents verrouillage auto des fonctionnalités prévues dans les normes pour verrouiller/déverrouiller la synchronisation des éléments.
  • Ajouté plus de code, espérons que cette aide à clarifier la situation
  • L'appel d'une std::mutex semaphore ne pas en faire un. Je vous suggère d'utiliser un nom différent, dans le cas où un jour vous ajoutez une réelle sémaphore à votre programme, et quelqu'un se fait complètement embrouillé...
  • À l'aide de la norme actuelle de classes, un 'semaphore' qui serait en fait constitué à l'aide d'un la variable de condition.

InformationsquelleAutor Angelo Cassano | 2014-06-17
  1. 14

    std::mutex est ni copiable, ni meubles. Y compris dans votre classe, il faut que votre classe devient non-copiable (mobiles) ainsi. Si vous voulez que votre classe soit copiable ou mobile, vous devrez indiquer au compilateur comment les objets de votre classe doivent être copiés ou déplacés par la mise en œuvre de copier/déplacer de la construction et des travaux vous-même. Par exemple:

    class synchronized_int {
  mutable std::mutex mtx;
  int value;
public:
  synchronized_int(int v = 0) : value(v) {}

  //Move initialization
  synchronized_int(synchronized_int&& other) {
    std::lock_guard<std::mutex> lock(other.mtx);
    value = std::move(other.value);
    other.value = 0;
  }

  //Copy initialization
  synchronized_int(const synchronized_int& other) {
    std::lock_guard<std::mutex> lock(other.mtx);
    value = other.value;
  }

  //Move assignment
  synchronized_int& operator = (synchronized_int&& other) {
    std::lock(mtx, other.mtx);
    std::lock_guard<std::mutex> self_lock(mtx, std::adopt_lock);
    std::lock_guard<std::mutex> other_lock(other.mtx, std::adopt_lock);
    value = std::move(other.value);
    other.value = 0;
    return *this;
  }

  //Copy assignment
  synchronized_int& operator = (const synchronized_int& other) {
    std::lock(mtx, other.mtx);
    std::lock_guard<std::mutex> self_lock(mtx, std::adopt_lock);
    std::lock_guard<std::mutex> other_lock(other.mtx, std::adopt_lock);
    value = other.value;
    return *this;
  }
};
    • Auriez-vous l'esprit de commenter un peu sur ce que tout ce que vous faites sur la Déplacer/Copier Affectation? J'aurais pensé à seulement deux lock_guards états sur leurs propres serait suffisant, et il semble comme si vous verrouillez les deux d'entre eux à l'aide de lock puis passer les écluses à un lock_guard, sans doute afin qu'ils déverrouillent automatiquement à la fin de la portée. Je suis juste curieux de savoir pourquoi vous avez fait cela de cette façon.
    • Chaque fois qu'un programme multithread blocs en attente sur Un mutex tout en maintenant mutex B, il court le risque de blocage: si un autre thread contient mutex B et, simultanément, des blocs en attente sur Un mutex, aucun thread jamais réveiller et de progresser à nouveau. La bibliothèque standard fournit std::lock comme un outil pour verrouiller plusieurs verrous tout en évitant un blocage. Votre analyse du reste du code est correct: une fois std::lock a verrouillé les deux les mutex, j'ai lock_guards adopter chacune des mutex, de sorte qu'ils doivent être débloqué au moment de quitter le champ d'application.
    InformationsquelleAutor Casey
  2. 2

    Déclarer votre mutex de façon dynamique et non pas statique.

    À votre Base de données en-tête de classe, de déclarer le mutex comme un pointeur, comme ça:

    mutex * semaphore;

    et à votre constructeur initialiser le mutex en appelant son constructeur:

    semaphore = new std::mutex();
    InformationsquelleAutor Derzu