27

複数のプロセスをフォークして、それらでセマフォを使用したいと考えています。これが私が試したものです:

sem_init(&sem, 1, 1);   /* semaphore*, pshared, value */
.
.
.
if(pid != 0){ /* parent process */
    wait(NULL); /* wait all child processes */

    printf("\nParent: All children have exited.\n");
    .
    .
    /* cleanup semaphores */
    sem_destroy(&sem);      
    exit(0);
}
else{ /* child process */
    sem_wait(&sem);     /* P operation */
    printf("  Child(%d) is in critical section.\n",i);
    sleep(1);
    *p += i%3;  /* increment *p by 0, 1 or 2 based on i */
    printf("  Child(%d) new value of *p=%d.\n",i,*p);
    sem_post(&sem);     /* V operation */
    exit(0);
}

出力は次のとおりです。

子(0) 分岐
child(1) 分岐
  Child(0) はクリティカル セクションにあります。
  Child(1) はクリティカル セクションにあります。
child(2) 分岐
  Child(2) はクリティカル セクションにあります。
child(3) 分岐
  Child(3) はクリティカル セクションにあります。
child(4) 分岐
  Child(4) はクリティカル セクションにあります。
  Child(0) *p=0 の新しい値。
  Child(1) *p=1 の新しい値。
  Child(2) *p=3 の新しい値。
  Child(3) *p=3 の新しい値。

  Child(4) *p=4 の新しい値。
親: すべての子が終了しました。

これは明らかに、セマフォが想定どおりに機能しなかったことを意味します。フォークされたプロセスでセマフォを使用する方法を説明できますか?

4

2 に答える 2

68

あなたが直面している問題は、sem_init()関数の誤解です。マニュアルページを読むと、次の ように表示されます。

pshared 引数は、このセマフォをプロセスのスレッド間で共有するか、プロセス間で共有するかを示します。

ここまで読んだら、pshared の非ゼロ値によってセマフォがプロセス間セマフォになると考えるでしょう。しかし、これは間違っています。読み進めると、共有メモリ領域にセマフォを配置する必要があることが理解できます。これを行うには、以下に示すように、いくつかの関数を使用できます。

pshared がゼロ以外の場合、セマフォはプロセス間で共有され、共有メモリの領域に配置する必要があります (shm_open(3)、mmap(2)、および shmget(2) を参照)。(fork(2) によって作成された子は親のメモリ マッピングを継承するため、セマフォにもアクセスできます。) 共有メモリ領域にアクセスできるすべてのプロセスは、sem_post(3)、sem_wait(3) などを使用してセマフォを操作できます。 .

このアプローチは他のアプローチよりも複雑だと思いsem_open()ますsem_init()

以下に、完全なプログラムを示します。

  • フォークされたプロセス間で共有メモリを割り当て、共有変数を使用する方法。
  • 共有メモリ領域で複数のプロセスによって使用されるセマフォを初期化する方法。
  • 複数のプロセスを fork し、すべての子プロセスが終了するまで親プロセスを待機させる方法。
#include <stdio.h>          /* printf()                 */
#include <stdlib.h>         /* exit(), malloc(), free() */
#include <sys/types.h>      /* key_t, sem_t, pid_t      */
#include <sys/shm.h>        /* shmat(), IPC_RMID        */
#include <errno.h>          /* errno, ECHILD            */
#include <semaphore.h>      /* sem_open(), sem_destroy(), sem_wait().. */
#include <fcntl.h>          /* O_CREAT, O_EXEC          */


int main (int argc, char **argv){
    int i;                        /*      loop variables          */
    key_t shmkey;                 /*      shared memory key       */
    int shmid;                    /*      shared memory id        */
    sem_t *sem;                   /*      synch semaphore         *//*shared */
    pid_t pid;                    /*      fork pid                */
    int *p;                       /*      shared variable         *//*shared */
    unsigned int n;               /*      fork count              */
    unsigned int value;           /*      semaphore value         */

    /* initialize a shared variable in shared memory */
    shmkey = ftok ("/dev/null", 5);       /* valid directory name and a number */
    printf ("shmkey for p = %d\n", shmkey);
    shmid = shmget (shmkey, sizeof (int), 0644 | IPC_CREAT);
    if (shmid < 0){                           /* shared memory error check */
        perror ("shmget\n");
        exit (1);
    }

    p = (int *) shmat (shmid, NULL, 0);   /* attach p to shared memory */
    *p = 0;
    printf ("p=%d is allocated in shared memory.\n\n", *p);

    /********************************************************/

    printf ("How many children do you want to fork?\n");
    printf ("Fork count: ");
    scanf ("%u", &n);

    printf ("What do you want the semaphore value to be?\n");
    printf ("Semaphore value: ");
    scanf ("%u", &value);

    /* initialize semaphores for shared processes */
    sem = sem_open ("pSem", O_CREAT | O_EXCL, 0644, value); 
    /* name of semaphore is "pSem", semaphore is reached using this name */

    printf ("semaphores initialized.\n\n");


    /* fork child processes */
    for (i = 0; i < n; i++){
        pid = fork ();
        if (pid < 0) {
        /* check for error      */
            sem_unlink ("pSem");   
            sem_close(sem);  
            /* unlink prevents the semaphore existing forever */
            /* if a crash occurs during the execution         */
            printf ("Fork error.\n");
        }
        else if (pid == 0)
            break;                  /* child processes */
    }


    /******************************************************/
    /******************   PARENT PROCESS   ****************/
    /******************************************************/
    if (pid != 0){
        /* wait for all children to exit */
        while (pid = waitpid (-1, NULL, 0)){
            if (errno == ECHILD)
                break;
        }

        printf ("\nParent: All children have exited.\n");

        /* shared memory detach */
        shmdt (p);
        shmctl (shmid, IPC_RMID, 0);

        /* cleanup semaphores */
        sem_unlink ("pSem");   
        sem_close(sem);  
        /* unlink prevents the semaphore existing forever */
        /* if a crash occurs during the execution         */
        exit (0);
    }

    /******************************************************/
    /******************   CHILD PROCESS   *****************/
    /******************************************************/
    else{
        sem_wait (sem);           /* P operation */
        printf ("  Child(%d) is in critical section.\n", i);
        sleep (1);
        *p += i % 3;              /* increment *p by 0, 1 or 2 based on i */
        printf ("  Child(%d) new value of *p=%d.\n", i, *p);
        sem_post (sem);           /* V operation */
        exit (0);
    }
}

出力

./a.out 
shmkey for p = 84214791
p=0 is allocated in shared memory.

How many children do you want to fork?
Fork count: 6 
What do you want the semaphore value to be?
Semaphore value: 2
semaphores initialized.

  Child(0) is in critical section.
  Child(1) is in critical section.
  Child(0) new value of *p=0.
  Child(1) new value of *p=1.
  Child(2) is in critical section.
  Child(3) is in critical section.
  Child(2) new value of *p=3.
  Child(3) new value of *p=3.
  Child(4) is in critical section.
  Child(5) is in critical section.
  Child(4) new value of *p=4.
  Child(5) new value of *p=6.

Parent: All children have exited.

失敗すると-1を返すshmkeyので、チェックするのは悪くありません。ftok()ただし、複数の共有変数があり、ftok()関数が複数回失敗した場合、shmkeywith 値-1を持つ共有変数は共有メモリの同じ領域に存在し、一方の変更が他方に影響を与えます。したがって、プログラムの実行は乱雑になります。これを回避するには、ftok() -1 が返されるかどうかを確認することをお勧めします (衝突が発生した場合に備えて重要な値を示したかったのですが、私が行ったように画面に出力するよりも、ソース コードをチェックインする方が適切です)。

セマフォの宣言と初期化の方法に注意してください。質問で行ったこととは異なります(sem_t semvs sem_t* sem)。さらに、この例に示されているとおりに使用する必要があります。sem_t*で定義して使用することはできませんsem_init()

于 2013-05-06T14:25:00.733 に答える
3

Linux minimal anonymous sem_init + mmap MAP_ANONYMOUS example

I like this setup as it does not pollute any global namespace as sem_open does.

The only downside is that MAP_ANONYMOUS is not POSIX, and I don't know any replacement: Anonymous shared memory? shm_open for example takes a global identifier just like sem_open.

main.c:

#define _GNU_SOURCE
#include <assert.h>
#include <semaphore.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main(int argc, char **argv) {
    pid_t pid;
    typedef struct {
        sem_t sem;
        int i;
    } Semint;

    Semint *semint;
    size_t size = sizeof(Semint);
    semint = (Semint *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, 0, 0);
    assert(semint != MAP_FAILED);
    /* 1: shared across processes
     * 0: initial value, wait locked until one post happens (making it > 0)
     */
    sem_init(&semint->sem, 1, 0);
    semint->i = 0;
    pid = fork();
    assert(pid != -1);
    if (pid == 0) {
        sleep(1);
        semint->i = 1;
        msync(&semint->sem, size, MS_SYNC);
        sem_post(&semint->sem);
        exit(EXIT_SUCCESS);
    }
    if (argc == 1) {
        sem_wait(&semint->sem);
    }
    /* Was modified on the other process. */
    assert(semint->i == 1);
    wait(NULL);
    sem_destroy(&semint->sem);
    assert(munmap(semint, size) != -1);
    return EXIT_SUCCESS;
}

Compile:

gcc -g -std=c99 -Wall -Wextra -o main main.c -lpthread

Run with sem_wait:

./main

Run without sem_wait:

./main 1

Without this synchronization, the assert is very likely to fail, since the child sleeps for one whole second:

main: main.c:39: main: Assertion `semint->i == 1' failed.

Tested on Ubuntu 18.04. GitHub upstream.

于 2018-08-27T15:25:45.470 に答える