Question

我在clang线程安全模型之后实现了以下互斥类（希望如此）。（http://clang.llvm.org/docs/ThreadSafetyAnalysis.html）

class CAPABILITY( "mutex" ) Mutex : public std::mutex
{
  public:
    void lock() ACQUIRE()
    {
        std::mutex::lock();
    }

    void unlock() RELEASE()
    {
        std::mutex::unlock();
    }
};

class SCOPED_CAPABILITY LockGuard : public std::unique_lock< std::mutex >
{
  public:
        LockGuard( Mutex& mu ) ACQUIRE( mu ) : std::unique_lock< std::mutex >( mu )
        {
        }

        ~LockGuard() RELEASE()
        {
        }
};

用法如下：

class Barrier
{
    ...

    Mutex mutex_;
    std::condition_variable cv_ GUARDED_BY( mutex_ );
    std::size_t min_count_ GUARDED_BY( mutex_ );
    std::size_t count_ GUARDED_BY( mutex_ );

    bool Barrier::waitFor( const std::chrono::microseconds& duration )
    {
        LockGuard lock( mutex_ );
        if ( count_ >= min_count_ )
        {
            return true;
        }
        else
        {
            // WARNING IS IN THE LINE BELOW
            return cv_.wait_for( lock, duration, [this]() { return count_ >= min_count_; } );  
        }
    }
};

我收到了警告： warning: reading variable 'count_' requires holding mutex 'mutex_' [-Wthread-safety-analysis]。

编译器的警告（clang 3.8 with -Wthread-safety）是否正确？如果是，违规行为究竟是怎么发生的？

Answer 1

因为编译器不清楚lambda表达式的计算位置，所以也需要注释lambda。

正确的行，不会产生任何错误

return cv_.wait_for( lock, duration, [this]() REQUIRES( mutex_ ) { return count_ >= min_count_; } );

Answer 2

此代码非常有问题。您继承自unique_lock，但您没有正确构建它！您拥有自己的互斥锁，可以锁定/解锁，但unique_lock拥有的互斥锁将保持未初始化状态。条件变量wait_for将在父锁定上调用release，并释放未锁定的互斥锁，从而锁定互斥锁。

我认为没有理由参与重新实现自定义类锁定的练习。请记住，标准库类几乎永远意味着继承。

使用std :: condition变量判断线程安全性

2 个答案: