c - 如何同时运行多个fork()？以及如何在c中使用信号量？

Question

我正在做一项作业，教授要求使用信号量解决哲学家就餐问题的解决方案。

这是迄今为止我的代码:

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

#define MAX_THINKING_TIME 1500  /* maximum thinking time in milliseconds */
#define MIN_THINKING_TIME 1000  /* minimum thinking time in milliseconds */
#define MAX_EATING_TIME   1000  /* maximum eating time in milliseconds */
#define MIN_EATING_TIME   750   /* minimum eating time in milliseconds */

/*
 * Macros to encapsulate the POSIX semaphore functions.
 */
#define semaphore_create(s,v)   sem_init( &s, 0, v )
#define semaphore_wait(s)           sem_wait( &s )
#define semaphore_signal(s)         sem_post( &s )
#define semaphore_release(s)    sem_destroy( &s )
typedef sem_t semaphore;

// Each chopstick is represented by a semaphore (shared between all processes).
semaphore *chopstick;

int NUM_PHILOSOPHERS; /* number of philosophers */
int NUM_REPETITIONS;  /* number of cycles */

/*
 * Generating a random number within a range.
 */
unsigned int randr(unsigned int min, unsigned int max)
{
    double scaled = (double)rand()/RAND_MAX;
    return (max - min +1) * scaled + min;
}

/*
 * To pick up his chopsticks, a philosopher does a semaphore wait on each.
 * Alternating order prevents deadlock.
 */
void pickup_chopsticks(int index)
{
    if(index % 2 == 0) /* Even number: Left, then right */
    {
        semaphore_wait(chopstick[(index+1) % NUM_PHILOSOPHERS]);
        printf("Philosopher #%d: I am picking up the left chopstick!\n", index+1);
        semaphore_wait(chopstick[index]);
        printf("Philosopher #%d: I am picking up the right chopstick!\n", index+1);
    }
    else /* Odd number: Right, then left */
    {
        semaphore_wait(chopstick[index]);
        printf("Philosopher #%d: I am picking up the right chopstick!\n", index+1);
        semaphore_wait(chopstick[(index+1) % NUM_PHILOSOPHERS]);
        printf("Philosopher #%d: I am picking up the left chopstick!\n", index+1);
    }
}

/*
 * To drop his chopsticks, a philosopher does a semaphore signal on each.
 * Order does not matter.
 */
void drop_chopsticks(int index)
{
    printf("Philosopher #%d: I am dropping the right chopstick!\n", index+1);
    semaphore_signal(chopstick[index]);
    printf("Philosopher #%d: I am dropping the left chopstick!\n", index+1);
    semaphore_signal(chopstick[(index+1) % NUM_PHILOSOPHERS]);
}

/*
 * Simulate a philosopher - endlessly cycling between eating and thinking
 * until his "life" is over.
 */
void start_philosopher(int index)
{
    int i; // A counter.

    for(i = 0; i < NUM_REPETITIONS; i++)
    {
        /* Hungry */
        printf("Philosopher #%d (Cycle #%d): I am hungry!\n", index+1, i+1);
        pickup_chopsticks(index);

        /* Eating */
        printf("Philosopher #%d (Cycle #%d): I am eating!\n", index+1, i+1);
        usleep(1000 * randr(MIN_EATING_TIME, MAX_EATING_TIME));
        drop_chopsticks(index);

        /* Thinking */
        printf("Philosopher #%d (Cycle #%d): I am thinking!\n", index+1, i+1);
        usleep(1000 * randr(MIN_THINKING_TIME, MAX_THINKING_TIME));
    }

    printf("Philosopher #%d: I am dead!\n", index+1);
    exit(0);
}

/*
 * The main function.
 */
int main(int argc, char *argv[])
{

    // If the input arguments are not 2 elements, display a message and return.
    if(argc != 3)
    {
        printf("You have to insert arguments in the form:\n");
        printf("Number_of_Philosopher Number_of_repeats\n");
        return -1;
    }

    // Set value of NUM_PHILOSOPHERS and NUM_REPETITIONS from the user input.
    NUM_PHILOSOPHERS = atoi(argv[1]);
    NUM_REPETITIONS  = atoi(argv[2]);
    int i; // A counter.

    // Allocate memory for the semaphores.
    chopstick = malloc(NUM_PHILOSOPHERS * sizeof(semaphore));

    // Create semaphores to represent "one user at a time" chopsticks.
    for(i = 0; i < NUM_PHILOSOPHERS; i++)
        semaphore_create(chopstick[i], 1);

    // Create n processes for n philosophers
    for(i = 0; i < NUM_PHILOSOPHERS; i++)
    {
        if(fork() == 0) start_philosopher(i);
        else wait();
    }
    // Release semaphore resources.
    for(i = 0; i < NUM_PHILOSOPHERS; i++)
        semaphore_release(chopstick[i]);

    // Free the memory.
    free(chopstick);

    return 0;
}

当我运行它时，我得到以下结果:

$ ./run 2 2
Philosopher #1 (Cycle #1): I am hungry!
Philosopher #1: I am picking up the left chopstick!
Philosopher #1: I am picking up the right chopstick!
Philosopher #1 (Cycle #1): I am eating!
Philosopher #1: I am dropping the right chopstick!
Philosopher #1: I am dropping the left chopstick!
Philosopher #1 (Cycle #1): I am thinking!
Philosopher #1 (Cycle #2): I am hungry!
Philosopher #1: I am picking up the left chopstick!
Philosopher #1: I am picking up the right chopstick!
Philosopher #1 (Cycle #2): I am eating!
Philosopher #1: I am dropping the right chopstick!
Philosopher #1: I am dropping the left chopstick!
Philosopher #1 (Cycle #2): I am thinking!
Philosopher #1: I am dead!
Philosopher #2 (Cycle #1): I am hungry!
^Z
[6]+  Stopped                 ./run 2 2

如您所见，我有两个问题:

• 除非进程 n 完成，否则进程 n+1 不会执行。
• 在之前运行程序的测试中，当第二个哲学家要求拿起筷子时，程序就会卡住。看来信号量没有发出信号，哲学家正在等待信号。

你能帮我修复这个程序吗？

Answer 1

通过将 wait() 移到执行 fork 的循环之外来解决问题 (1)。

问题 (2) 的解决方法是使用带有 MAP_SHARED 标志的 mmap() 分配内存以允许其在子级之间共享，并使用 sem_init(&s, 1, v) 选项进行 sem_init 调用 - 使用0 作为第二个选项意味着它用于进程内(即在同一 pid 中，而不是使用 fork 的子进程)。

chopstick = mmap(0, NUM_PHILOSOPHERS * sizeof(semaphore), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);