相关疑难解决方法(0)

存在一种众所周知的锁定多个锁的方法,其依赖于根据该排序选择固定的线性排序和获取锁.

例如,在"获取锁定两个互斥锁并避免死锁"的答案中提出了这一点.特别是,基于地址比较的解决方案似乎非常优雅和明显.

当我试图检查它是如何实际实现的时候,令我惊讶的是,我发现这个解决方案没有被广泛使用.

引用内核文档 - 锁定不可靠指南:

教科书会告诉你,如果你总是以相同的顺序锁定,你将永远不会遇到这种僵局.实践会告诉你这种方法不能扩展:当我创建一个新的锁时,我不太了解内核,无法确定它适合的5000锁定层次结构中的位置.

PThreads似乎根本没有内置这样的机制.

Boost.Thread提出了完全不同的解决方案,lock()因为多个(2到5个)互斥锁基于尝试并锁定尽可能多的互斥锁.

这是Boost.Thread源代码的片段(Boost 1.48.0,boost/thread/locks.hpp:1291):

template<typename MutexType1,typename MutexType2,typename MutexType3>
void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3)
{    
    unsigned const lock_count=3;
    unsigned lock_first=0;
    for(;;)
    {    
        switch(lock_first)
        {    
        case 0:
            lock_first=detail::lock_helper(m1,m2,m3);
            if(!lock_first)
                return;
            break;
        case 1:
            lock_first=detail::lock_helper(m2,m3,m1);
            if(!lock_first)
                return;
            lock_first=(lock_first+1)%lock_count;
            break;
        case 2:
            lock_first=detail::lock_helper(m3,m1,m2);
            if(!lock_first)
                return;
            lock_first=(lock_first+2)%lock_count;
            break;
        }    
    }    
}    

其中成功lock_helper返回0和未成功锁定的互斥锁数量.

为什么这个解决方案比地址或任何其他类型的ID 更好？我没有看到指针比较有任何问题,使用这种"盲"锁定可以避免这种问题.

关于如何在库级别解决此问题还有其他想法吗？