0

我正在处理教授要求使用信号量解决用餐哲学家问题的解决方案的任务。

到目前为止，这是我的代码：

#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 不会执行。
  • 在之前运行程序的测试中，当第二个哲学家要求拿起筷子时，它被卡住了。似乎信号量没有发出信号，而哲学家正在等待信号。

你能帮我修复程序吗？

4

2 回答 2

1

在 fork 新进程的循环中，新的父进程（fork返回非零）等待新进程完成。将and放在循环外else调用。wait

于 2011-11-25T18:16:16.533 回答
1

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

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

chopstick = mmap(0, NUM_PHILOSOPHERS * sizeof(semaphore), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
于 2011-11-25T18:21:54.160 回答