Question

我最近开始使用boost :: thread（WinXP，VS10，BoostPro），发现互斥锁可以被任何线程解锁，而不是只拥有它的线程。另外，基本的lock_guard + mutex组合正在对多个lock（）和unlock（）进行一些内部计数，但我认为这不是一个大问题。

有人知道为什么它是以这种方式设计的吗？这是故意的吗？（或者我的构建环境/库可能有问题吗？）

示例app：

#include <iostream>
#include <boost/thread.hpp>

using namespace std;


class NamedThread
{
public:
    NamedThread(string name_, boost::mutex& mtx_) :
      mtx(mtx_), name(name_) {}

    void operator ()()
    {
        for (int i = 0; i < 10; ++i)
        {
            boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
            cout << name << endl;

            //boost::lock_guard<boost::mutex> guard1(mtx);
            //boost::lock_guard<boost::mutex> guard2(mtx);

            boost::unique_lock<boost::mutex> guard1(mtx);
            boost::unique_lock<boost::mutex> guard2(mtx);
        }


    }

    string name;
    boost::mutex& mtx;
};

class UnlockerThread
{
public:
    UnlockerThread(string name_, boost::mutex& mtx_) :
      mtx(mtx_), name(name_) {}

    void operator ()()
    {
        for (int i = 0; i < 100; ++i)
        {
            boost::this_thread::sleep(boost::posix_time::milliseconds(3000));
            cout << name << ": unlocking" << endl;
            mtx.unlock(); // !!! IT WORKS !!!
        }
    }

    string name;
    boost::mutex& mtx;
};


int main()
{
    boost::mutex mtx;

    NamedThread th2("Thread1", mtx);
    boost::thread t2(th2);

    UnlockerThread th3("UnlockerThread", mtx);
    boost::thread t3(th3);

    t2.join();

    char ch;
    cin >> ch;
    return 0;
}

谢谢，

Answer 1

boost文档非常清楚，调用mutex.unlock的前提条件是“当前线程拥有* this”。这并不意味着违反该前提条件将导致异常/错误/崩溃（尽管它可能对调试版本很好），但在这种情况下您不能依赖任何特定行为。

win32实现似乎使用原子指令实现了互斥锁的大部分逻辑 - 可能这是因为在win32上对更复杂的互斥锁类型（递归/定时）的支持有限。 Win32的本机关键部分只能用于简单的互斥锁（而且Win32的本机互斥锁对于进程内互斥体来说太重了）。

提升：互斥锁可能从任何线程解锁？

1 个答案: