Comment est-ce que je rends une fonction thread sûre en C ++?

Disons que j'ai un pool de threads qui a 5 enfants threads. Et ils sont de l'appel d'une fonction appelée "functionA()" Comment faire la fonction de thread-safe?

Également si ces 5 fils sont appelés en même temps, ils sont exécutés en même temps?
ou n'ont-ils attendre jusqu'à ce qu'un thread qui travaille actuellement dans la fonction d'être fini ?

Merci d'avance..

source d'informationauteur codereviewanskquestions

  1. 13

    Une fonction est déjà thread-safe si elle ne modifie pas non de la mémoire locale et il n'a pas d'appeler n'importe quelle fonction qui le fait. Dans ce (trivial) des cas, vous n'avez pas à faire quoi que ce soit.

    Vous avez vraiment envie de penser à la protection des données, des fonctions pas. Par exemple, supposons que la fonction modifie non-local de la structure de données X. Fournir un mutex pour protéger les X et le verrouiller avant chaque accès et déverrouiller après. Vous pouvez avoir plus d'une fonction qui accède à X (par exemple insertX(), deleteX(), ...). Tant que vous protéger les données que vous serez OK.

  2. 2

    Vous devez vous assurer que la fonction s'exécute de façon identique à chaque fois qu'elle est appelée.

    Cela signifie généralement que vous avez besoin pour protéger toutes les données qui est accessible/écrit dans la fonction.

    Pour stand-alone gratuit fonctions qui généralement signifie la suppression des éléments statiques de la fonction.

    Si vous faites référence à une fonction membre d'une classe, alors vous devez être plus prudent, parce que la classe va généralement de stocker des données independantely de la fonction membre qui peut changer entre les appels à ce membre. Vous aurez généralement le faire avec un mutex.

    Par exemple:

    //Threadsafe because the function do not change each time it is called
double add_one(double d)
{
  return d+1;
}

struct A
{
  double m_data;

  //Not thread safe because if function called simultaneously then m_data could change more than once before it is returned
  double 
  run(double d)
  {
    m_data += d;
    return m_data/2.0;
  }
}

    Cela peut être corrigé par l'ajout d'un mutex qui exige que les deux threads ne peuvent pas l'exécution de l'exécution membre simultanément. Voir Coup De Pouce.Fil de discussion pour une bonne mutex exemple.

    struct A
{
  double m_data;
  mutex m_mutex;

  //Thread safe because mutex protects m_data from being written by multiple threads at once
  double 
  run(double d)
  {
    lock(m_mutex);  //lock the function, unlock on destruction.
    m_data += d;
    return m_data/2.0;
  }
}
  3. 1

    À l'aide d'un mutex, vous pouvez le faire.

    :

    mutex_lock(&mutex);
functionA();
mutex_unlock(&mutex);

    ou à l'intérieur de functionA();

    int functionA() {
mutex_lock(&mutex);
//code
mutex_unlock(&mutex);
}

    prudent avec la deuxième solution, parce que si la fonction a d'autres trajectoires de sortie (un retour dans le milieu par exemple) et que le mutex de ne pas débloqué, vous avez une situation appelée impasse.

  4. 0

    Cela dépend de ce que vous voulez/ce que vous comprenez en vertu des threads.
    Normalement, vous ne voulez pas les threads d'accéder aux mêmes données simultanément de sorte que vous sérialiser.
    Mais cela signifie que si un thread est en fonction de tous les autres doivent attendre. Ceci est appelé un mutex(exclusion mutuelle).
    L'autre moyen serait d'avoir plusieurs threads dans la fonction, mais un nombre limité.
    De là, vous pouvez appliquer un sémaphore.

    Alors, que voulez-vous faire?

  5. 0

    Une façon de faire cela est d'utiliser un mutex pour s'assurer qu'un seul thread en cours d'exécution dans la fonction à tout moment. Bien sûr, cela suppose que c'est le type de fil de sécurité vous faites allusion. Être thread-safe pourrait signifier beaucoup de choses différentes. Par exemple, prendre une lecture d'Eric Lipperts post intitulé Quelle est cette chose que vous appelez un "thread-safe"?

    Si ces 5 fils sont appelés en même temps alors sont-elles exécutées simultanément, ou font-ils attendre jusqu'à ce qu'un thread qui travaille actuellement dans la fonction d'être fini?

    À moins que vous imposent un mécanisme de synchronisation (par exemple, un mutex) le nombre de threads d'exécuter la fonction en même temps. Si oui ou non c'est un problème pour votre fonction et quelle est la solution, dépend de l'accès aux données des modèles de cette fonction.