Ne fourchue enfant les processus utilisent le même sémaphore?

Disons que je crée un sémaphore. Si j'ai la fourche un tas de processus enfants,
seront-ils tous encore utiliser le même sémaphore?

Il dépend de la façon dont vous avez créé le sémaphore, de le faire avec un IPC de sémaphore voir sémaphore.c: Illustration de la simple sémaphore en passant pour un exemple.

Aussi, supposons que je créer une structure avec des sémaphores à l'intérieur et fourchue. Faire
tous les processus enfants utilisent toujours le même sémaphore? Si non, serait
le stockage de cette structure+dans la mémoire partagée, sémaphores permettent à l'enfant
les processus à utiliser pour la même sémaphores?

Pour que le travail de votre sémaphore doit être stocké dans un espace partagé entre le parent et l'enfant tel processus de la mémoire partagée, et pas seulement créé sur la pile ou sur le tas, car il sera copié lorsque le processus de fourches.

Je suis vraiment confus au sujet de la façon dont ma fourche enfant les processus peuvent utiliser le
même les sémaphores.

Le sémaphore peuvent être partagées entre les threads ou processus. Inter-processus de partage est mis en œuvre sur le niveau du système d'exploitation. Deux ou plusieurs processus différents peuvent partager le même sémaphore, même si ces processus n'ont pas été créés par bifurquer un seul processus parent.

Voir cet exemple pour partager une sans nom UNIX sémaphore entre un processus parent et son enfant (pour compiler avec gcc, vous aurez besoin de la -pthread drapeau):

#include <semaphore.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
int main(void)
{
/* place semaphore in shared memory */
sem_t *sema = mmap(NULL, sizeof(*sema), 
PROT_READ |PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,
-1, 0);
if (sema == MAP_FAILED) {
perror("mmap");
exit(EXIT_FAILURE);
}
/* create/initialize semaphore */
if ( sem_init(sema, 1, 0) < 0) {
perror("sem_init");
exit(EXIT_FAILURE);
}
int nloop=10;
int pid = fork();
if (pid < 0) {
perror("fork");
exit(EXIT_FAILURE);
}
if (pid == 0) { 
/* child process*/
for (int i = 0; i < nloop; i++) {
printf("child unlocks semaphore: %d\n", i);
if (sem_post(sema) < 0) {
perror("sem_post");
}
sleep(1);
}
if (munmap(sema, sizeof(sema)) < 0) {
perror("munmap");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
if (pid > 0) {
/* back to parent process */
for (int i = 0; i < nloop; i++) {
printf("parent starts waiting: %d\n", i);
if (sem_wait(sema) < 0) {
perror("sem_wait");
}
printf("parent finished waiting: %d\n", i);
}
if (sem_destroy(sema) < 0) {
perror("sem_destroy failed");
exit(EXIT_FAILURE);
}
if (munmap(sema, sizeof(sema)) < 0) {
perror("munmap failed");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
}

La sortie sera:

parent starts waiting: 0
child unlocks semaphore: 0
parent finished waiting: 0
parent starts waiting: 1
child unlocks semaphore: 1
parent finished waiting: 1
...

Vous voudrez peut-être lire Les sémaphores sous Linux ainsi, mais il faut être conscient que l'exemple d'UNIX, les sémaphores d'un fork donné ne fonctionne pas parce que l'auteur a oublié d'utiliser la MAP_ANONYMOUS drapeau dans mmap.

OriginalL'auteur