使用try_lock增强锁定

Question

我正试图用Boost 1.46.1来解决锁定问题 - 我尝试过一些东西,但我不开心 - 所以我很乐意听到来自干净利落的输入.

线程A:

• 必须始终等待并获取关键数据部分的锁定
• 更新一些关键数据
• 手动解锁(或作用范围)

线程B - 必须永远不会阻塞(try_lock？) - 如果获得锁定,则从提到的关键部分读取数据

我不确定我是否需要shared_lock或者我是否可以解决这个问题.

编辑,我的代码看起来像:线程A:

{
 // Critical section
 boost::mutex::scoped_lock  lock( _mutex) ;
}

线程B:

boost::mutex::scoped_lock lock(_mutex, boost::try_to_lock);
if( lock ) {

}

但是我无法记录失败的try_lock - 所以我想知道它是否真的有效.

问候,保罗

Answer 1

对我而言似乎它正在工作,除了范围锁不是FIFO,即请求锁的第一个线程,不是第一个获得锁的线程.我使用以下代码进行测试:

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

boost::mutex mutex;

void threadA()
{
    for (int i = 10; i > 0; )
    {
        boost::mutex::scoped_lock lock(mutex);
        {
            fprintf(stderr, "Locked by A\n");
            usleep(100000);
            fprintf(stderr, "Unlocked by A\n");
            i--;
        }
    }
}

void threadB()
{
    for (int i = 10; i > 0; )
    {
        boost::mutex::scoped_lock lock(mutex, boost::try_to_lock);
        if (lock)
        {
            fprintf(stderr, "Locked by B\n");
            usleep(100000);
            fprintf(stderr, "Unlocked by B\n");
            i--;
        }
        else
        {
            fprintf(stderr, "Lock failed in B\n");
            usleep(100000);
        }
    }
}

int main(int argc, char **argv)
{
    boost::thread a(threadA);
    boost::thread b(threadB);
    a.join();
    b.join();
}

我得到了输出

Locked by A
Lock failed in B
Lock failed in B
Unlocked by A
Locked by A
Unlocked by A
Locked by A
Lock failed in B
Unlocked by A
Locked by A
Lock failed in B
Unlocked by A
Locked by A
Lock failed in B
Unlocked by A
Locked by A
Lock failed in B
Unlocked by A
Locked by A
Lock failed in B
Unlocked by A
Locked by A
Lock failed in B
Unlocked by A
Locked by A
Lock failed in B
Lock failed in B
Unlocked by A
Locked by A
Unlocked by A
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B
Locked by B
Unlocked by B