c++ - 这是从信号处理程序返回值的可靠方法吗？

Question

我想收集已终止子进程的 pid，但与信号处理程序通信时遇到问题...我没有 c(++)11。这是有效的吗？另请考虑到我的程序将是多线程的(但队列将仅从一个线程使用)。

#include <iostream>
#include <csignal>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
#include <sys/wait.h>
template<typename _ValueType, int _Capacity>
class signal_result_queue
{
public:
    static const int capacity = _Capacity;
    typedef _ValueType value_type;
private:
    //+1 so we can distinguish empty from full
    volatile value_type _data[capacity+1];
    volatile sig_atomic_t _base;
    volatile sig_atomic_t _next;
    volatile sig_atomic_t _overflows;
public:
    signal_result_queue()
    : _base(0)
    , _next(0)
    , _overflows(0)
    {}

    void push_sh(value_type value)
    {
        int base = _base; // we are not interrupted anyway
        int next = _next; // same here
        int before_base = wrap(base-1);
        if(next == before_base)
        {
            ++_overflows;
        }
        else
        {
            _data[next] = value;
            _next = wrap(next+1);
        }
    }

    int overflows_t1()
    {
        int overflows = _overflows;
        _overflows -= overflows;
        return overflows;
    }

    bool pop_t1(value_type& result)
    {
        // this is only changed by us.
        int base = _base;
        // It might increase but no problem
        int next = _next;

        if(base == next)
        {
            return false;
        }
        else
        {
            result = _data[base];
            _base = wrap(base+1);
            return true;
        }
    }
private:
    static int wrap( int i )
    {
        while(i>=capacity+1)
        {
            i-=(capacity+1);
        }
        while(i<0)
        {
            i+=(capacity+1);
        }
        return i;
    }
};

signal_result_queue<pid_t, 20> q;

void sigchld_handler(int)
{
    pid_t pid;
    while((pid = waitpid(static_cast<pid_t>(-1), 0, WNOHANG)) > 0){
        q.push_sh(pid);
    }
}

int main()
{
    struct sigaction sa;
    sa.sa_handler = &sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
    if (sigaction(SIGCHLD, &sa, 0) == -1) {
      perror(0);
      std::exit(1);
    }

    for(int i=0;i<10;i++)
    {
        pid_t pid = fork();
        if(pid == 0) // child
        {
            sleep(i);
            return 0;
        }
        else if(pid == -1) // error
        {
            std::cout << "fork error" << std::endl;
        }
        else // parent
        {
            std::cout << "fork pid: " << pid <<  std::endl;
        }
    }
    int terminated = 0;
    do
    {
        sleep(1);
        int overflows = q.overflows_t1();
        if(overflows > 0)
        {
            std::cout << "Overflow in queue:" << overflows << std::endl;
        }
        pid_t val;
        while(q.pop_t1(val))
        {
            terminated++;
            std::cout << "Terminated: " << val <<  std::endl;
        }
    } while(terminated < 10);
    return 0;
}

Answer 1

这不是一种安全的方法，原因有两个:

• volatile 不足以避免多线程程序中的竞争情况。 sig_atomic_t 对于信号重入来说保证是原子的，但我怀疑它对于多线程来说是否足够。
• 使用全局队列变量不符合信号处理程序的重入要求。

使用 C++11，您可以使用原子而不是 volatile 。如果没有 C++11，您需要使用 mutex lock 来保护对队列的并发访问。保护对共享变量的访问。这样就可以解决上述两个问题。

如有疑问，请进行额外演示:

只是为了更详细地说明它是多么不安全:

假设处理第一个进程信号:

    int base = _base; // acces to _base is atomic. It's protected ONLY DURING THE STATEMENT
    int next = _next; // same here
    int before_base = wrap(base-1);

现在想象另一个线程调用处理程序，并在 CPU 上运行。为简单起见，假设第一个被系统调度程序搁置。因此处理程序的第二个实例执行:

    int base = _base; // SAME BASE IS STORED LOCALLY  
    int next = _next; // SAME NEXT IS STORED LOCALLY 
    int before_base = wrap(base-1);

因此，此时，处理程序的两个实例在其本地拷贝 base 和 next 中具有相同的索引。现在第二个实例继续:

        ...
        _data[next] = value;   // value is stored in the queue
        _next = wrap(next+1);  // and _next is incremented.  

这里调度程序再次唤醒第一个实例，该实例立即继续:

        _data[next] = value;   // USES ITS LOCAL COPY OF NEXT, WRITE IN SAME PLACE THAN THE OTHER INSTANCE !!
        _next = wrap(next+1);  // and _next is incremented BASED ON LOCAL COPY.  

因此此时，在您的队列中，您将只有应该存储的两个值之一。