Fils de locking mutex

Ce que vous devez faire est d’appeler pthread_mutex_lock pour sécuriser un mutex, comme ceci:

 pthread_mutex_lock(&mutex); 

Une fois que vous faites cela, tout autre appel à pthread_mutex_lock(mutex) ne sera pas renvoyé tant que vous n’appelez pas pthread_mutex_unlock dans ce thread. Donc, si vous essayez d’appeler pthread_create, vous pourrez créer un nouveau thread et ce thread pourra utiliser (de manière incorrecte) la ressource partagée. Vous devez appeler pthread_mutex_lock partir de votre fonction fooAPI , et la fonction attendra que la ressource partagée soit disponible.

Donc, vous auriez quelque chose comme ça:

 #include  #include  int sharedResource = 0; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; void* fooAPI(void* param) { pthread_mutex_lock(&mutex); printf("Changing the shared resource now.\n"); sharedResource = 42; pthread_mutex_unlock(&mutex); return 0; } int main() { pthread_t thread; // Really not locking for any reason other than to make the point. pthread_mutex_lock(&mutex); pthread_create(&thread, NULL, fooAPI, NULL); sleep(1); pthread_mutex_unlock(&mutex); // Now we need to lock to use the shared resource. pthread_mutex_lock(&mutex); printf("%d\n", sharedResource); pthread_mutex_unlock(&mutex); } 

Modifier: l’utilisation des ressources d’un processus à l’autre suit la même approche de base, mais vous devez mapper la mémoire dans votre autre processus. Voici un exemple d’utilisation de shmem:

 #include  #include  #include  #include  #include  struct shared { pthread_mutex_t mutex; int sharedResource; }; int main() { int fd = shm_open("/foo", O_CREAT | O_TRUNC | O_RDWR, 0600); ftruncate(fd, sizeof(struct shared)); struct shared *p = (struct shared*)mmap(0, sizeof(struct shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); p->sharedResource = 0; // Make sure it can be shared across processes pthread_mutexattr_t shared; pthread_mutexattr_init(&shared); pthread_mutexattr_setpshared(&shared, PTHREAD_PROCESS_SHARED); pthread_mutex_init(&(p->mutex), &shared); int i; for (i = 0; i < 100; i++) { pthread_mutex_lock(&(p->mutex)); printf("%d\n", p->sharedResource); pthread_mutex_unlock(&(p->mutex)); sleep(1); } munmap(p, sizeof(struct shared*)); shm_unlink("/foo"); } 

Ecrire le programme pour apporter des modifications à p-> sharedResource est laissé comme exercice pour le lecteur. 🙂

Oublier de noter, en passant, que le mutex doit avoir l’atsortingbut PTHREAD_PROCESS_SHARED, de sorte que les pthreads fonctionneront entre les processus.

Q1.) En supposant que le processus B essaie de s’approprier le même mutex que celui que vous avez verrouillé dans le processus A, alors le processus B ne peut pas accéder à sharedResource tant que le mutex est verrouillé. jusqu’à ce qu’il soit libéré par le processus A. Il reviendra de la fonction mutex_lock () lorsque le mutex est verrouillé (ou lorsqu’une erreur survient!)

Q2.) Dans le processus B, assurez-vous de toujours verrouiller le mutex, d’accéder à la ressource partagée, puis de déverrouiller le mutex. Vérifiez également le code retour de la routine mutex_lock (pMutex) pour vous assurer que vous possédez réellement le mutex et déverrouillez SEULEMENT le mutex si vous l’avez verrouillé. Faites de même avec le processus A.

Les deux processus devraient essentiellement faire la même chose lors de l’access au mutex.
lock () Si le verrou réussit, alors {access sharedResource unlock ()}

Q3.) Oui, il y a beaucoup de diagrammes: =) https://www.google.se/search?q=mutex+thread+process&rlz=1C1AFAB_enSE487SE487&um=1&ie=UTF-8&hl=en&tbm=isch&source=og&sa=N&tab=wi&ei = ErodUcSmKqf54QS6nYDoAw & biw = 1200 & bih = 1730 & sei = FbodUbPbB6mF4ATarIBQ

Un processus est constitué d’au moins un thread (pensez à la fonction principale). Le code multi-thread ne fera que générer plus de threads. Les mutex sont utilisés pour créer des verrous autour des ressources partagées afin d’éviter toute corruption de données / comportement inattendu / indésirable. Fondamentalement, il fournit une exécution séquentielle dans une configuration asynchrone – l’exigence pour laquelle provient d’opérations non-const non atomiques sur des structures de données partagées.

Une description vivante de quels mutex serait le cas des personnes (fils) faisant la queue pour visiter les canvasttes (ressource partagée). Alors qu’une personne (thread) utilise la salle de bain pour se soulager (opération non-const non atomique), il / elle doit s’assurer que la porte est verrouillée (mutex), sinon cela pourrait conduire à une capture complète (comportement indésirable). )

Ci-dessous, l’extrait de code vous aidera à comprendre le concept mutex-lock-unlock. Essayez de tester le code à sec. (De plus, en variant le temps d’attente et le temps de traitement, vous pouvez vous faire comprendre).

Code pour votre référence:

 #include  #include  void in_progress_feedback(int); int global = 0; pthread_mutex_t mutex; void *compute(void *arg) { pthread_t ptid = pthread_self(); printf("ptid : %08x \n", (int)ptid); int i; int lock_ret = 1; do{ lock_ret = pthread_mutex_trylock(&mutex); if(lock_ret){ printf("lock failed(%08x :: %d)..attempt again after 2secs..\n", (int)ptid, lock_ret); sleep(2); //wait time here.. }else{ //ret =0 is successful lock printf("lock success(%08x :: %d)..\n", (int)ptid, lock_ret); break; } } while(lock_ret); for (i = 0; i < 10*10 ; i++) global++; //do some stuff here in_progress_feedback(10); //processing-time here.. lock_ret = pthread_mutex_unlock(&mutex); printf("unlocked(%08x :: %d)..!\n", (int)ptid, lock_ret); return NULL; } void in_progress_feedback(int prog_delay){ int i=0; for(;i