exécution indépendante des processus avec sémaphores

Question

J'ai créé un code pour un projet unix en utilisant le code semaphores.My est la suivante:

#include <unistd.h> 
#include <sys/types.h> 
#include <sys/wait.h> 
#include <sys/mman.h> 
#include "display.h" 
#include <semaphore.h> 
#include <fcntl.h> 
#include <stdlib.h> 
#include <stdio.h> 

typedef struct { 
sem_t p1; 
sem_t p2; 
}SemPair ; 

int main (int argc, char *argv[]) { 
SemPair *sem = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED |MAP_ANONYMOUS , -1, 0); 
int i=0; 
sem_init(&(sem->p1),1,0); 
sem_init(&(sem->p2),1,0); 

pid_t pid = fork(); 
if (!pid) 
{ 
    for(i=0;i<10;i++) { 
     sem_wait(&(sem->p2)); 
     display("Hello world\n"); 
     sem_post(&(sem->p1)); } 
    } 
    else 
    { 
    for(i=0;i<10;i++) { 

     sem_post(&(sem->p2)); 
     sem_wait(&(sem->p1)); 
     display("Goodnight world\n"); 
     sleep(1);} 

} 
sem_destroy(&(sem->p1)); 
sem_destroy(&(sem->p2)); 

return 0; 

}

Comme vous pouvez voir mon problème est que je ne veux pas obtenir l'affichage dans l'ordre un par un, mais plutôt au hasard. Donc, ma sortie est celle-ci.

Hello world 
Goodnight world 
Hello world 
Goodnight world 
Hello world 
Goodnight world 
.... 

Au lieu de cela je veux que les processus soient pas exécutés en ordre pour la sortie sera quelque chose comme ceci:

Hello world 
    Hello world 
    Hello world 
    Goodnight world 
    Hello world 
    Goodnight world 
    Goodnight world 
    .... 

Answer 1

Cela ne se produira pas la façon dont vous utilisez sémaphores.

Tout le problème de la transformation de la sortie (et de la raison pour laquelle vous utilisez des sémaphores) est qu'un processus est interrompu au milieu de son écriture.

Sans sémaphores, vous avez ceci:

processus
1. A commence à imprimer "Hell"
2. processus A est interrompu; d'autres processus s'exécutent
3. processus B finit par obtenir son temps de partage et commence à imprimer "bon"
4. le processus B est interrompu; d'autres processus sont exécutés
processus
5. A arrive à finir d'écrire « monde o »

Vous savez, bien sûr. Vous pouvez voir comment cela provoque la déformation de la sortie.

Le point est comment les sémaphores changent cela. Au moment où vous arrivez au point 3, le processus B sera bloqué à cause de son appel de sem_wait (btw, votre "processus B" ne gère pas correctement le sémaphore). Lorsque le processus A remet le sémaphore à 1, sem_post déverrouillera immédiatement le processus B et le laissera continuer avant que le processus A puisse revenir au début de la boucle et exécuter à nouveau sem_wait.