Question

我想用共享内存和信号量创建一个C程序。应该有两个子进程。两个孩子都有不同的int号。然后有一个目标号码应该写在共享内存中。现在两个孩子都应该从目标数中减去他们的数字，直到目标数量低于或等于0.我不希望出现竞争条件。这就是为什么我尝试使用信号量。但它对我不起作用。这是我的代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/wait.h>
#include <errno.h>
#include <sys/sem.h>

#define SEG_SIZE sizeof(int)
#define NUM_OF_CHILDS 2

int main(int argc, char *argv[]){

    int i, shm_id, sem_id, *shar_mem;
    int pid[NUM_OF_CHILDS];
    long waittime = 100;
    unsigned short marker[1];

    /* Define the numbers and the goal number */

    int numbers[2] = {28, 23};
    int goal = (numbers[0] + numbers[1]) * 4;   

    /* Create semaphor */

    if((sem_id = semget(IPC_PRIVATE, 1, IPC_CREAT|0644)) == -1){

        perror("semget()");
        exit(EXIT_FAILURE);

    }

    marker[0] = 1;

    /* All sem's to 1 */

    semctl(sem_id, 1, SETALL, marker);

    /* Create shared memory */

    if((shm_id = shmget(IPC_PRIVATE, SEG_SIZE, IPC_CREAT|0600)) == -1){

        perror("shmget()");
            exit(EXIT_FAILURE); 

    }
    if((shar_mem = (int *)shmat(shm_id, 0, 0)) == (int *) -1){

        perror("shmat()");
        exit(EXIT_FAILURE); 

    }
    *shar_mem = goal;

    /* Create child processes */

    for(i = 0; i < NUM_OF_CHILDS; i++){

        pid[i] = fork();
        if(pid[i] < 0){

            printf("Error!\n");
            exit(1);

        }
        if(pid[i] == 0){
            int count = 0;  
            /* Child processes */

            /* Structs for semaphor */

            struct sembuf enter, leave;

            enter.sem_num = leave.sem_num = 0;      
            enter.sem_flg = leave.sem_flg = SEM_UNDO;
            enter.sem_op = -1;              /* DOWN-Operation */
            leave.sem_op = 1;               /* UP-Operation */

            /* Join critical area */

            semop(sem_id, &enter, 1);

            while(*shar_mem > 0){

                usleep(waittime);
                *shar_mem -= numbers[i];

                count++;
            }

            printf("%i\n", count);

            /* Leave critical area */

            semop(sem_id, &leave, 1);

            exit(0);

        }

    }

    /* Wait for childs. */

    for(i = 0; i < NUM_OF_CHILDS; i++){

        waitpid(pid[i], NULL, 0);

    }

    /* Is goal equal 0 or lower? */

    int returnv;

    if(*shar_mem == 0){

        /* No race conditions */

        returnv = 0;

    }
    else {

        /* Race conditions */

        returnv = 1;

    }

    /* Close shared memory and semaphores */

    shmdt(shar_mem);
    shmctl(shm_id, IPC_RMID, 0);
    semctl(sem_id, 0, IPC_RMID);

    return returnv;

}

当共享内存值最后为0时，应该没有竞争条件。如果低于0，则存在竞争条件。而且我总是低于0.最重要的是，我计算每个孩子减去他的数字的次数。结果：第一个孩子8次，第二个孩子0次。任何人都可以帮我吗？

Answer 1

将while循环调整为类似的东西，以便在减去一次后离开临界区：

for ( ; ; ) {
  usleep(waittime);
  semop(sem_id, &enter, 1);
  if (*shar_mem <= 0) {
    semop(sem_id, &leave, 1);
    break;
  }
  *shar_mem -= numbers[i];
  semop(sem_id, &leave, 1);
  count++;
}

但正如我的评论中所述，并不能保证两个孩子交替减去他们的数字，即可能小于零的结果

Answer 2

在评论中你评论道：

我试图将semop部分放入循环中。现在第一个孩子有8个计数，第二个孩子有1个计数。 [...]我必须使用信号量。

显然，仅将关键部分边界移动到循环内部是不够的。这是因为无法保证当一个进程通过递增信号量而离开临界区时，另一个进程将立即进入临界区。相反，第一个过程可能会循环并在第二个过程进入之前重新进入临界区。实际上，这个结果很可能是因为循环很紧，我们知道退出临界区的进程当前是在某些CPU上安排的。

可以通过在临界区之外的循环中引入延迟来解决这个问题，但这有点麻烦。首先，它不必要地减慢了程序。另一方面，虽然足够长的延迟可能使问题极不可能显现，但没有延迟可以保证问题不会显现。你总是受系统调度程序的支配。但是，由于你已经有了延迟，你可以通过把它放在关键部分之外来使你所希望的行为更有可能表现出来。

有几种方法可以解决这个问题，它提供了各种理想的语义而没有人为的延迟。所有这些都涉及至少一个信号量。以下是两种可能性：

为每个进程创建一个单独的信号量。选择一个初始化为1，并将其余部分初始化为0.在循环顶部，每个进程递减其自己的信号量，在底部递增 next 进程的信号量。然后这些过程以循环方式运行。
除了用于保护关键部分的信号量之外，还可以使用另外两个信号量在循环顶部创建“循环屏障”。循环屏障是一种可重复使用的构造，它可以使任何固定数量的进程/线程在任何进程之前到达给定点。这不会使进程严格交替，但它会阻止任何进程在其他进程之前进行多次循环迭代。它的优点是无论协调多少进程，它只需要三个信号量。

前者更容易概念化和编写，即使它对流程排序提供了更强的保证。

C - 共享内存和信号量

2 个答案: