c - linux c 编程中的信号

Question

我正在编写一个包含 3 个进程的系统，Judge、Player 1 和 player 2。

我使用信号 kill(playerPid,SIGUSR1) 让 judge 在轮到他时唤醒 player， 和一个信号 kill(judge,SIGHUP) 以在回合完成后唤醒裁判。

在每个 kill signal 之后我使用一个 pause() 所以进程不会继续。 问题有时是在 kill signal 之后，例如从 player 到 judge，judge 在玩家之前醒来正在执行他的 pause()。 下次 judge 唤醒这个 player 他会 pause 并且我的程序将被堆栈，因为所有 3 processes 处于 pause 状态，没有人可以唤醒它们。

所以我的问题是: kill 命令后应该发生什么？

1。当前进程一直持续到pause()，然后转到他发出信号的进程。 例如:

 kill(judge, SIGHUP);
    //stops here and goes to the judge.      
 pause();

这就是我的代码中有时会发生的情况，我在 pause() 上遇到了所有进程。

2。当前进程停止并转到他刚刚发出信号的进程。 例如:

kill(judge, SIGHUP);
pause();
//stops here and going to the judge.

**这是我的代码中大部分时间发生的情况。

在我的代码中，行为发生了变化，有时像数字 1，有时像数字 2。

我做错了什么？

进程是否有可能在接收到信号的处理函数完成运行之前唤醒？

或者进程是否有可能在 kill 信号之后、到达暂停行之前暂停？如果是这样，为什么以及我该如何处理？

这是我的代码:

 ///////////////////////signal handlers

void sigHandler(int signo)
{
    printf("Received signal %d\n", signo);

    if(signo == SIGHUP )//fatehr gets it from son
    {
        signal(SIGHUP ,sigHandler);
        printf("son woke up father\n");
    }
    else if (signo == SIGUSR1)//son gets it from father
    {
        signal(SIGUSR1, sigHandler);
        printf("Judge waking player B\n");
    }
    else if (signo == SIGUSR2)//father gets it from son
    {
        signal(SIGUSR2, sigHandler);
        printf("Judge waking player A\n");
    }
    else if (signo == SIGTERM)//son get it when father kill them
    {
        signal(SIGTERM, sigHandler);

        printf("%d im dead\n", getpid());
        kill(getppid(), SIGUSR2);

        exit(1);
    }
    else if (signo == SIGINT)//father get it to play round with ^C
    {
        signal(SIGINT, sigHandler);

        printf("play round!!!!!!!!!!!!\n");
    }
}

void sigHandler2(int signo)
{
    if (signo == SIGINT)//son get it to play round with ^C
    {
        signal(SIGINT, sigHandler2);
    }
}


void wakePlayer(int player,int turn, int* boardPtr)
{
    boardPtr[27] = 0;
    while (boardPtr[27] != 1)//while player didnt finish his turn
    {
        if (turn==1)
            kill(player, SIGUSR1);
        else
            kill(player, SIGUSR2);
        pause();
    }

}


///////////////////////End of signal handlers
int main(){

    int j = 1;;
    int player1;
    int player2;
    int judge;
    time_t t;
    key_t key;
    int   shmid;
    int  *boardPtr;
    judge = getpid();
    srand(time(NULL) *(5));

    shmid = createShm(&boardPtr);//creating shm
    boardPtr[1] = 2;


    player1 = fork();//create player 1
    if (player1 == -1)
    {
        printf("error in fork");
        exit(1);
    }
    if (player1>0)//not player 1
    {
        player2 = fork();//create player 2
        if (player2 == -1)
        {
            printf("error in fork");
            exit(1);
        }
        if (player2>0)//This is The Judge!********************************************************************************
        {
            signal(SIGHUP, sigHandler);//signal from player after he did his turn
            signal(SIGINT, sigHandler);//catch the ^c to make the next turn
            printf("father started\n");
            while(boardPtr[1]!=0)//Players didnt set up their handlers
            {
                sleep(1);       
            }
            printf("father initiating\n");
            initiation(boardPtr, player1, player2);//create the board and choose a player to start

            printBoard(boardPtr, 0);//print the current board.

            while (checkWin(boardPtr) == 0)//while no one won.
            {
                if (boardPtr[26] == 1)//if it is player "b" turn.
                    wakePlayer(player1,1, boardPtr);
                else //if it is player "a" turn.    
                    wakePlayer(player2,2, boardPtr);

                //pause();
                printBoard(boardPtr, j);//print the current board.
                boardPtr[26] = (boardPtr[26] * 2) % 3;//change turns
                j++;
            }

            printf("game finished!\n");
            killItWithFire(player1, player2, shmid, &boardPtr);//cleaning up after match.
            printf("Judge is suiciding, goodbye!\n");
            exit(1);
        }
        else if (player2 == 0)//this is player 2!******************************************************************************
        {
            signal(SIGUSR2, sigHandler);//signal from judge to make a turn
            signal(SIGTERM, sigHandler);//signal from judge to terminate
            signal(SIGINT, sigHandler2);//get the ^c and pause.
            printf("%d player A started\n", getpid());

            boardPtr[1]--;//mark player A handlers are set.
            pause();
            while (1)
            {
                int r = roll(1);
                printf("%d player A threw a %d\n", getpid(), r);
                if (boardPtr[22] == 0)//checking if it is an initation round
                {
                    boardPtr[21] = r;
                }
                else
                {
                    turn(2, r, boardPtr);//makes a turn
                }
                boardPtr[27] = 1;//mark that i finished my turn.
                kill(judge, SIGHUP);//signal to judge after turn.  
                pause();



            }

        }
    }
    else//this is player 1!**********************************************************************************************
    {

        signal(SIGUSR1, sigHandler);//signal from judge to make a turn
        signal(SIGTERM, sigHandler);//signal from judge to terminate
        signal(SIGINT, sigHandler2);//signal to pause when player gets a ctrl C
        printf("%d player B started\n", getpid());

        boardPtr[1]--;//mark player A handlers are set.
        pause();
        while (1)
        {           
            int r = roll(2);
            printf("%d player B threw a %d\n", getpid(), r);
            if (boardPtr[22] == 0)//flag to check if it is an initiation round.
            {
                boardPtr[20] = r;
            }
            else
            {
                turn(1, r, boardPtr);//player b makes a turn
            }
            boardPtr[27] = 1;//marks that player B finished his turn. 
            kill(judge, SIGHUP);//signal to judge after turn.  
            pause();

        }

    }
    return 0;
}

Answer 1

用这样的东西替换每个 kill/pause 对

/* These flags are set in the interrupt handler, therefore we should
   declare them volatile, so that the compiler can anticipate that
   they can be changed outside the normal program flow */
volatile int sigusr1_flag, sigusr2_flag;

void sighandler(int signo) {
  if(signo == SIGUSR1)
    sigusr1_flag = 1;
  if(signo == SIGUSR2)
    sigusr2_flag = 1;
}

void kill_and_wait(pid_t pid, int signaltosend, int signaltowait, volatile int *flag) {
  sigset_t mask, savemask;
  /* Create a signal set with only one element */
  sigemptyset(&mask);
  sigaddset(&mask, signaltowait);
  /* Block the signal that we are expecting back from the other process,
     so if it arrives right after the kill(), it will be put "on hold",
     and delivered first when it's unblocked. The active signal set is
     saved to savemask, we'll use it later to temporarily unblock the
     signal that we are expecting. */
  sigprocmask(SIG_BLOCK, &mask, &savemask);
  /* Clear the flag that would be set when the response signal has arrived */
  *flag = 0;
  /* Now we can safely send our signal. */
  kill(pid, signaltosend);
  /* Repeat until the flag is set in the interrupt handler. We do this 
     because some other signal could arrive here that we would otherwise
     ignore, but it wakes up our process early. */
  while(!*flag) {
    /* It sets the mask of blocked signals temporarily to savemask, which
       was the state when we entered ths funcion, effectively unblocking
       signaltowait, then waits for any signal to arrive. */
    sigsuspend(&savemask);
  }
  /* restore the original signal mask */
  sigprocmask(SIG_UNBLOCK, &mask, NULL);
}