在 c++ 中定期中断并在必要时终止程序

Question

我需要你的帮助。 程序 A 使用 fork() 执行程序 B。 程序 B 的进程每 5 秒被中断一次。 如果用户在一定时间内输入任何键，该过程将继续并在相同的时间间隔后再次中断。 如果没有输入密钥，程序 A 和程序 B 都会提前终止。 我试过下面的代码，但它不起作用。 有什么建议/技巧可以帮助我吗？

#include <iostream>
#include <chrono>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>

using namespace std;
using namespace chrono;

int pid;

void signal_handler(int signum) {
    cout << "Programm B is interrupted. Please enter any key within 5 or the programm will be terminated" << endl;
    kill(pid,SIGSTOP);
    alarm(5);
    pause();
    alarm(5);

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

  //Usage
  if(string(argv[1]) == "h" || string(argv[1]) == "help"){
    cout << "usage" << endl;
    return 0;
  }

  signal(SIGALRM, signal_handler);
  pid = fork();

  if (pid == 0) {

    cout << "Name of programm B: " << argv[1] << endl;
    cout << "PID of programm B: " << getpid() << endl;
    execvp(argv[1], &argv[1]);

  } else if (pid > 0) {

    cout << "PID of programm A: " << getpid() << endl;

    high_resolution_clock::time_point t1 = high_resolution_clock::now();
    waitpid(pid, nullptr, 0);
    high_resolution_clock::time_point t2 = high_resolution_clock::now();

  
    auto duration = duration_cast<milliseconds>(t2 - t1).count();
    cout << "Computing time: " << duration << "ms" << endl;
  } else {

    cerr << "error << endl;
    return 1;

}
  return 0;
}

任何帮助或解决方案。 顺便说一句，我是 c++ 的初学者。

Answer 1

信号可能会变得棘手，并且您的方法存在很多问题。

你应该：

• 在main中启动定时器（ alarm(5) ）
• 在你生成孩子之后进行 sighandler 注册和计时器启动（或者你有点冒险在fork和execvp之间的孩子中运行信号处理程序）
• 使用sigaction而不是signal来注册信号，因为与后者不同，前者具有清晰的可移植语义
• 围绕waitpid在EINTR上循环（因为信号中断会导致waitpid因EINTR而失败）

至于处理程序，它需要

• 仅使用异步信号安全函数
• 在read周围注册另一个alarm()
• 为read周围的alarm解锁SIGALRM ，但在你以某种方式将自己标记为已经在你的SIGALRM信号处理程序之前，这样处理程序的潜在递归进入可以做不同的事情（杀死孩子并退出）

（对于最后一点，如果您使用.sa_flags = SA_NODEFER注册处理程序，则可以不使用信号解除阻塞，但这样做的缺点是打开您的应用程序，导致许多外部发送（通过 kill）SIGALRM 导致堆栈溢出。如果你想精确地处理外部发送的SIGALRM s，你可以用.sa_flags=SA_SIGINFO注册处理程序并使用info->si_code来区分SIGALRM的用户发送和警报发送，大概会中止外部发送的）

它可能看起来像这样（根据您的代码）：

#include <iostream>
#include <chrono>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
#include <string.h>

//AS-safe raw io helper functions
ssize_t             /* Write "n" bytes to a descriptor  */
writen(int fd, const char *ptr, size_t n)
{
    size_t      nleft;
    ssize_t     nwritten;

    nleft = n;
    while (nleft > 0) {
        if ((nwritten = write(fd, ptr, nleft)) < 0) {
            if (nleft == n)
                return(-1); /* error, return -1 */
            else
                break;      /* error, return amount written so far */
        } else if (nwritten == 0) {
            break;
        }
        nleft -= nwritten;
        ptr   += nwritten;
    }
    return(n - nleft);      /* return >= 0 */
}
ssize_t writes(int fd, char const *str0) { return writen(fd,str0,strlen(str0)); }
ssize_t writes2(char const *str0) { return writes(2,str0); }

//AS-safe sigprockmask helpers (they're in libc too, but not specified as AS-safe)
int sigrelse(int sig){
    sigset_t set; sigemptyset(&set); sigaddset(&set,sig);
    return sigprocmask(SIG_UNBLOCK,&set,0);
}
int sighold(int sig){
    sigset_t set; sigemptyset(&set); sigaddset(&set,sig);
    return sigprocmask(SIG_BLOCK,&set,0);
}

#define INTERRUPT_TIME 5

using namespace std;
using namespace chrono;

int pid;
volatile sig_atomic_t recursing_handler_eh; //to differentiate recursive executions of signal_handler


void signal_handler(int signum) {
    char ch;
    if(!recursing_handler_eh){
        kill(pid,SIGSTOP);

        writes2("Programm B is interrupted. Please type enter within 5 seconds or the programm will be terminated\n");

        alarm(5);
        recursing_handler_eh = 1;
        sigrelse(SIGALRM);

        if (1!=read(0,&ch,1)) signal_handler(signum);
        alarm(0);
        sighold(SIGALRM);

        writes2("Continuing");
        kill(pid,SIGCONT);
        recursing_handler_eh=0;
        alarm(INTERRUPT_TIME);
        return;
    }
    kill(pid,SIGTERM);
    _exit(1);

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

  //Usage
  if(string(argv[1]) == "h" || string(argv[1]) == "help"){
    cout << "usage" << endl;
    return 0;
  }

  pid = fork();

  if (pid == 0) {
    cout << "Name of programm B: " << argv[1] << endl;
    cout << "PID of programm B: " << getpid() << endl;
    execvp(argv[1], &argv[1]);

  } else if (pid < 0) { cerr << "error" <<endl; return 1; }

  struct sigaction sa; sa.sa_handler = signal_handler; sigemptyset(&sa.sa_mask); sa.sa_flags=0; sigaction(SIGALRM, &sa,0);
  //signal(SIGALRM, signal_handler);
  alarm(INTERRUPT_TIME);

  cout << "PID of programm A: " << getpid() << endl;

  high_resolution_clock::time_point t1 = high_resolution_clock::now();
  int r;
  do r = waitpid(pid, nullptr, 0); while(r==-1 && errno==EINTR);
  high_resolution_clock::time_point t2 = high_resolution_clock::now();


  auto duration = duration_cast<milliseconds>(t2 - t1).count();
  cout << "Computing time: " << duration << "ms" << endl;
  return 0;
}

并不是说上面只会等待回车键。 要等待任何键，您需要将终端置于原始/cbreak 模式并在退出时恢复之前的设置（理想情况下也是信号死亡）。