Question

我正在尝试使以下代码永远不允许+的数量大于-的数量。我正在考虑添加仅c sleep(1)的简单行，但是我很好奇是否有更好的方法来使数量相等。应该保持无限循环。

int main(){
 if(fork() ==0)
    while(1){
       write(1,"-",1)
   }

  else
     while(1){

       write(1, "+",1);
   }

return 0;
}

使用信号灯可以正确使用此功能吗？

int main(){

int parent_sem = get_semaphore(0);
int child_sem = get_semaphore(1);

 if(fork() ==0)
    while(1){
        sem_wait(child_sem);
       write(1,"-",1);
       sem_signal(parent_sem);
   }

  else
     while(1){
       sem_wait(parent_sem);
       write(1, "+",1);
       sem_signal(child_sem);
   }

return 0;
}

Answer 1

这是信号量示例的固定版本。我已经分配了共享内存，以便可以在fork上的两个进程访问信号量（我忘记了这是必要的，对不起），并修复了信号量类型和调用。

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

int main() {
    // Create shared memory for two semaphores
    sem_t* sem = mmap(NULL, 2 * sizeof(sem_t), PROT_READ | PROT_WRITE,
                      MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    // Initialise parent and child semaphores: parent = 1, child = 0
    sem_t* parent_sem = sem;
    sem_t* child_sem = sem + 1;    
    sem_init(parent_sem, 1, 1);
    sem_init(child_sem, 1, 0);

    if (fork() == 0) {
        while(1) {
            // Child process
            sem_wait(child_sem);
            write(1, "-", 1);
            sem_post(parent_sem);
        }
    } else {
        while(1) {
            // Parent process
            sem_wait(parent_sem);
            write(1, "+", 1);
            sem_post(child_sem);
        }
    }

    return 0;
}

Answer 2

这是关闭的（使用信号）：

#include <unistd.h>
#include <stdio.h>
#include <signal.h>

void usr1handler() {
}

int main(void) {
        int pid;

        signal(SIGUSR1, usr1handler);

        if ((pid = fork()) == 0) {
                while (1) {
                        pause();
                        write(1, "-", 1);
                        fflush(stdout);
                        kill(getppid(), SIGUSR1);
                }
        }
        else {

                sleep(1);

                while (1) {
                        write(1, "+", 1);
                        fflush(stdout);
                        kill(pid, SIGUSR1);
                        pause();
                }
        }

}

主要问题是比赛条件。如果一个进程先进入kill（）函数，然后另一个进程进入pause（），则程序将冻结。不过，这可能足以使您入门。我在那儿留下了一个睡眠，因此您可以看到它确实打印均匀。

使fork无限执行相等的次数

2 个答案: