c++ - 这个接口(interface)是线程安全的吗？

Question

我想制作一个控制循环界面。

它有 should_stop() 方法来检查循环是否应该中断或继续。

它会监听 SIGINT 信号(Ctrl+C)，在它收到信号后，should_stop() 方法返回 True。

现在看来这个接口(interface)可以正常工作了。

但我不确定这个接口(interface)是线程安全的。

LoopInterface.h文件

#include "signal.h"
#include "pthread.h"

#define LOCK(mutex)     pthread_mutex_lock(&mutex)
#define UNLOCK(mutex)   pthread_mutex_unlock(&mutex)

class LoopInterface {
public:
    LoopInterface(){
        LOCK(_lock_is_signal_registered);
        bool temp = _is_signal_registered;
        UNLOCK(_lock_is_signal_registered);
        if(!temp)
        {
            register_signal();
        }
    }

    bool should_stop()
    {
        LOCK(_lock_should_stop);
        bool temp = _should_stop;
        UNLOCK(_lock_should_stop);
        return _should_stop;
    }

private:

    static void register_signal()
    {
        LOCK(_lock_is_signal_registered);
        _is_signal_registered = true;
        UNLOCK(_lock_is_signal_registered);

        signal(SIGINT, &LoopInterface::signal_handler);
    }

    static void signal_handler(int sig){
        LOCK(_lock_should_stop);
        _should_stop = true;
        UNLOCK(_lock_should_stop);
    }

    static bool _should_stop;
    static bool _is_signal_registered;
    static pthread_mutex_t _lock_should_stop, _lock_is_signal_registered;
};

LoopInterface.cpp文件

#include "LoopInterface.h"
bool LoopInterface::_should_stop = false;
bool LoopInterface::_is_signal_registered = false;
pthread_mutex_t LoopInterface::_lock_should_stop;
pthread_mutex_t LoopInterface::_lock_is_signal_registered;

这就是它的使用方式。

/************Threads*************/
#include "LoopInterface.h"
class A : public LoopInterface{

};

void threadX(){
    A a;
    while(!a.should_stop()){
        //do something...
    }
}

你能告诉我这个接口(interface)是线程安全的吗？还是不是？

如果不是，是什么问题？

---

其他问题

我的同步代码还有一个问题。

由于signal_handler中调用pthread_mutex_lock而should_stop方法锁定了同一个mutex，所以死锁发生的频率很高。

然后我找到了一个 article声明不应在信号处理程序中调用与线程相关的函数。

我想我应该找到另一种方法来同步我的成员变量。

Answer 1

显然，此代码不是线程安全的:变量 _should_stop 由某个不受控制的线程中的信号设置，并在运行其自己的线程的 LoopInterface 中读取。根本没有同步。如果只有一个线程，则此方法只能是线程安全的。

您可以使用

使代码线程安全(相对于这个特定变量)

static std::atomic<bool> _should_stop;

由于此时您对任何其他值不感兴趣，您可以使用 std::memory_order_relaxed 标志读取变量。

如果LoopInterface的构造函数是从多线程调用的，当然你还需要同步访问_is_signal_registered。