Serrure Pthread Mutex débloquée par différents fils

Une question Naïve ..

J'ai lu avant de dire - "UN MUTEX doit être déverrouillé que par le thread qui l'a enfermé."

Mais j'ai écrit un programme où THREAD1 serrures mutexVar et s'en va dormir. Puis THREAD2 pouvez directement déverrouiller mutexVar faire certaines opérations et de retour.

==> je sais que tout le monde dire pourquoi je le fais ?? Mais ma question est: Est - ce une bonne attitude de MUTEX ??

==> Ajouter l'exemple de code

void *functionC()
{
   pthread_mutex_lock( &mutex1 );
   counter++;
   sleep(10);
   printf("Thread01: Counter value: %d\n",counter);
   pthread_mutex_unlock( &mutex1 );
}

void *functionD()
{
   pthread_mutex_unlock( &mutex1 );
   pthread_mutex_lock( &mutex1 );
   counter=10;
   printf("Counter value: %d\n",counter);
}

int main()
{
   int rc1, rc2;
   pthread_t thread1, thread2;

   if(pthread_mutex_init(&mutex1, NULL))
   printf("Error while using pthread_mutex_init\n");

   if( (rc1=pthread_create( &thread1, NULL, &functionC, NULL)) )
   {   
      printf("Thread creation failed: %d\n", rc1);
   }   

   if( (rc2=pthread_create( &thread2, NULL, &functionD, NULL)) )
   {   
      printf("Thread creation failed: %d\n", rc2);
   }

source d'informationauteur codingfreak

  1. 17

    Ce que vous avez fait est tout simplement pas légal, et le comportement est indéfini. Mutex seulement exclure les threads que les règles du jeu. Si vous avez essayé de verrouiller mutex1 de fil 2, le fil serait bloqué, bien sûr; c'est ce qui est requis de le faire. Il n'y a rien dans la spec, qui dit ce qui se passe si vous essayez de déverrouiller un mutex qui ne vous appartient pas!

  2. 20

    Pthreads a 3 différents types de mutex: Rapide mutex, récursive mutex, et la vérification des erreurs de mutex. Vous avez utilisé un rapide mutex qui, pour des raisons de performances, ne vérifiera pas pour cette erreur. Si vous utilisez le contrôle d'erreur mutex sur Linux, vous trouverez que vous obtenez les résultats que vous attendez.

    Ci-dessous est un petit hack de votre programme comme un exemple et une preuve. Il verrouille le mutex dans le main() et le code de déverrouillage dans le thread va échouer. 

    #include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>

/*** NOTE THE ATTR INITIALIZER HERE! ***/
pthread_mutex_t mutex1 = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;

int counter = 0;


void *functionD(void* data)
{
   int rc;

   if ((rc = pthread_mutex_unlock(&mutex1)) != 0)
   {
       errno = rc;
       perror("other thread unlock result");
       exit(1);
   }

   pthread_mutex_lock(&mutex1);
   counter=10;
   printf("Thread02: Counter value: %d\n",counter);

   return(data);
}


int main(int argc, char *argv[])
{
   int rc1;
   pthread_t thread1;

   if ((rc1 = pthread_mutex_lock(&mutex1)) != 0)
   {
       errno = rc1;
       perror("main lock result");
   }

   if( (rc1 = pthread_create(&thread1, NULL, &functionD, NULL)))
   {
      printf("Thread creation failed: %d\n", rc1);
   }

   pthread_join(thread1, NULL);
}
  3. -2

    Un mutex est utilisé pour prévenir plusieurs threads d'exécution de code qui n'est sûr que pour un seul thread à la fois.

    Pour ce faire un mutex a plusieurs caractéristiques:

    1. Un mutex peut gérer les conditions de course associé avec plusieurs threads tentent de "verrouiller" le mutex dans le même temps, et toujours avec un fil de gagner la course.

    2. N'importe quel thread qui perd la course est mis à dormir de façon permanente jusqu'à ce que le mutex est déverrouillé. Le mutex tient à jour une liste de ces threads.

    3. Une main le "verrouillage" de l'un et seulement un des threads en attente lorsque le mutex est déverrouillé par le thread qui a été tout simplement de l'utiliser. Le mutex va se réveiller de ce thread.

    Si ce type de modèle est utile pour d'autres fins, puis aller de l'avant et de l'utiliser pour une raison différente.

    Revenir à votre question. Disons que vous avez été la protection du code à partir de plusieurs thread accède à un mutex et disons, 5 fils ont été en attente pendant que le thread A été l'exécution du code. Si le fil B (pas un de ceux qui attendent depuis qu'ils sont en permanence dormi à l'heure actuelle) déverrouille le mutex, un autre thread va commencer à exécuter le code en même temps que la thread A. Probablement pas souhaité.

    Peut-être que si nous savions ce que l'on pense à utiliser le mutex pour nous avons pu donner une meilleure réponse. Êtes-vous essayer de débloquer un mutex après un thread a été annulée? Avez-vous de code peut gérer 2 threads à la fois, mais pas trois, et il n'y a pas de mutex qui permet à 2 fils grâce à une époque?