POSIX Семафор: Почему родительский процесс получает семафор до того, как его освободит?

Question

#include <semaphore.h> 

int main(void) 
{ 
    int pfds[2]; 
    char buff[20]; 
    sem_t sem; 

    sem_init(&sem, 1, 1); 
    pipe(pfds); 


    if (!fork()) { 
     printf("Child: Waiting to acquire semaphore\n"); 
     sem_wait(&sem); 
     printf("child acquires lock\n"); 
     sleep(5); 
     write(pfds[1], "Hello", 6); /* make stdout same as pfds[1] */ 
     close(pfds[0]); /* we don't need this */ 
     printf("child releases lock\n"); 
     sem_post(&sem); 
    } 
    else { 
     printf("Parent: Waiting to acquire semaphore\n"); 
     sem_wait(&sem); 
     printf("Parent acquires lock\n"); 
     read(pfds[0],buff,6); /* we don't need this */ 
     printf("Parent read: %s",buff); 
     printf("parent releases lock\n"); 
     sem_post(&sem); 
    } 
    sem_destroy(&sem); 
    return 0; 
} 

Выше - это простая трубка, которую я создал, в которой ребенок пишет, а родительский читает. Я поставил переменную семафора, инициализированную на 1, так что, пока ребенок пишет, родитель должен ждать. Добавлен умышленный «сон», чтобы увидеть, что печатается родительский процесс, вращающийся «Родитель: Ожидание получения семафора».

The expected sequence should be: 
Child: Waiting to acquire semaphore 
child acquires lock...(delay of 5 secs here) 
child releases lock 

Parent: Waiting to acquire semaphore 
Parent acquires lock 
Parent read..bla-bla 
parent releases lock 

However it happens: 
[root@localhost interview]# ./a.out 
Child: Waiting to acquire semaphore 
child acquires lock 
Parent: Waiting to acquire semaphore 
Parent acquires lock -> NOTE: Parent acquires lock before child releases it 
child releases lock 
Parent read: Hello 
parent releases lock 

Вопрос: Каким образом родитель получает блокировку в то время как ребенок задерживается и до сих пор держит его, и еще не выпустили семафора?

Кроме того, есть ли способ убедиться, что ребенок всегда сначала приобретает семафор, так как он должен писать в трубу?

EDIT: Благодаря @jxh. Вот модифицированный код, который отлично работает (вставка для ссылки каждого).

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <semaphore.h> 
#include <sys/mman.h> 

int main(void) 
{ 
    int pfds[2]; 
    char buff[20]; 


    sem_t *sem = mmap(0, sizeof(sem_t), PROT_READ|PROT_WRITE, 
        MAP_SHARED|MAP_ANONYMOUS, -1, 0); 
    sem_init(sem, 1, 0); 
    pipe(pfds); 


    if (!fork()) { 
     write(pfds[1], "Hello", 6); /* make stdout same as pfds[1] */ 
     close(pfds[0]); /* we don't need this */ 
     printf("child releases semaphore\n"); 
     sem_post(sem); 
    } 
    else { 
     printf("Parent: Waiting to acquire semaphore\n"); 
     sem_wait(sem); 
     printf("Parent acquires lock\n"); 
     read(pfds[0],buff,6); /* we don't need this */ 
     printf("Parent read: %s\n",buff); 
     printf("parent releases lock\n"); 
     sem_post(sem); 
    } 
    sem_destroy(sem); 
    return 0; 
} 

Answer 1

После fork() нет никакой гарантии, что ребенок проходит перед родителем, и я уверен, что это, как правило, родительский процесс, который продолжает выполнение на планировщик ОС после fork().

семафора должно быть в общей памяти, как это было предложено VoidPointer и QWR, и указывается в man page:

Если pshared отличен от нуля, то семафор разделяется между процессами, и должны расположены в области разделяемой памяти (см shm_open(3), mmap(2) и shmget(2))

можно выделить семафор в разделяемой памяти с mmap(), как это:.

sem_t *sem = mmap(0, sizeof(sem_t), PROT_READ|PROT_WRITE, 
        MAP_SHARED|MAP_ANONYMOUS, -1, 0); 
assert(sem != MAP_FAILED); 

Вы настроите свой семафор на 1, что позволяет первый вызов sem_wait(), чтобы добиться успеха. В вашем коде оба родителя и ребенка пытаются вызвать sem_wait() в то же время, что означает, что кто-то, кто попадает туда первым, сначала приобретет его.

Вместо того, чтобы звонить как sem_wait(), вы можете инициализировать семафор до 0 и разрешить родительскому вызову sem_wait(). Ребенок не ждет, но звонит sem_post() после того, как это будет сделано, что просыпает родителя.

Answer 2

http://linux.die.net/man/7/sem_overview Процесс совместно используемый семафор должен быть помещен в области совместно используемой памяти (например, System V сегмент общей памяти создан при shmget (2), или POSIX, общего объект встроенной памяти создан при shm_open (3)).

Answer 3

После fork родитель и ребенок будут содержать переменную sem в совершенно другой области. Выполнение sem_wait(&sem) будет ссылаться на совершенно другую память в родительском и дочернем, и, следовательно, оба приобретают семафор.

Если вы хотите семафор между различными процессами, то вы должны использовать shared memory, как указано на странице руководства пользователя sem_init here, а также страницу открывания глаз is here.