标签: mutex

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

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

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

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

教科书会告诉你,如果你总是以相同的顺序锁定,你将永远不会遇到这种僵局.实践会告诉你这种方法不能扩展:当我创建一个新的锁时,我不太了解内核,无法确定它适合的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 更好？我没有看到指针比较有任何问题,使用这种"盲"锁定可以避免这种问题.

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

C#中的互斥锁和信号量是什么？我们需要实施的地方？

我们如何在多线程中与他们合作？

我已经阅读了很多次,无论是在网络上还是网络上,互斥体都比关键部分/信号量/插入你的首选同步方法慢.但我从未见过任何论文或研究或其他什么来支持这一主张.

那么,这个想法来自哪里？这是神话还是现实？互斥体真的慢吗？

我想使用此问题或此问题中的代码来创建系统范围的互斥锁.
这在大多数系统上都可以正常工作,但在德语XP安装中,我收到"无法翻译某些或所有身份引用"的错误.问题是"Everyone"组在这个系统上被称为"Alle".

那么如何在所有独立于OS语言的系统上获得正确的IdentityReference来为"Everone"或"Users"创建MutexAccessRule？

我想知道如何配置pthread互斥锁以查看我的代码中是否存在任何锁定争用点.(谁喜欢有争议的代码,对吧？:)我知道如何对代码进行更一般的分析,正如我在这里提到的那样.但我想知道是否有任何工具或选项可用于配置互斥锁定,这将提供有关互斥锁定争用的指标/统计数据,以查看我是否有任何问题区域.

这是一些背景和背景:

最近我使用Cavium Octeon CPU开发了一个嵌入式C++项目.Octeon SDK使用自旋锁实现互斥式样式同步.通过Octeon文档,我发现了一种分析自旋锁的方法,以便能够看到每个自旋锁在等待锁变为可用时必须旋转多少次.要使用它,我必须进行条件编译,然后每次自旋锁旋转时它会递增一个计数器,然后我可以查询微调器等待值.所以,我所做的是封装自旋锁并添加了为系统中使用的所有自旋锁转储自旋锁微调器等待值的功能.实际价值并没有多大意义,但有一些与其他人相比具有非常高的价值,我专注于减少对这些人的争论.

我知道这对于自旋锁来说可能相当容易,因为它只是每次旋转一个计数器,但通过相关的pthread手册页和头文件读取我没有找到类似的东西,是否有可用于pthread互斥锁？

我真的很想避免像每个锁之前和之后花时间做一些hacky.

PS:互斥体的复数是多少？互斥,muteces,mutexi,muti ??? 互斥量从来没有对我说话.

该pthread_mutex_timedlock文档说abs_timeout需要CLOCK_REALTIME.但是,我们都知道,对于特定持续时间的计时(由于系统时间调整)是不合适的.

有没有办法让pthread锁定超时CLOCK_MONOTONIC可移植？pthread_cond_timedwait也是如此.

我遇到了一个(基本的)自旋锁互斥锁的问题,似乎没有按预期工作.

4个线程正在递增受此互斥锁保护的非原子计数器.结果与使互斥体看起来破碎的预期结果不匹配.

示例输出:

  result: 2554230
expected: 10000000

在我的环境中,它发生在以下条件下:

• flag是的std::atomic<bool>,其他任何东西,如std::atomic<int>或std::atomic_flag(和test_and_set)工作正常.

• 使用gcc 6.3.1和-O3flag 在X86_64上编译

我的问题是,有什么可以解释这种行为？

#include <iostream>
#include <vector>
#include <atomic>
#include <thread>
#include <mutex>
#include <assert.h>

class my_mutex {
    std::atomic<bool> flag{false};

public:
    void lock()
    {
        while (flag.exchange(true, std::memory_order_acquire));
    }

    void unlock()
    {
        flag.store(false, std::memory_order_release);
    }
};


my_mutex mut;
static int counter = 0;


void increment(int cycles)
{
    for (int i=0; i < cycles; ++i)
    {
        std::lock_guard<my_mutex> lck(mut);

        ++counter;
    }
} …

与“普通”互斥体相比，什么是“异步”互斥体？Mutex我相信这是 tokio和普通 std lib之间的区别Mutex。但从概念上讲，我不明白互斥体如何“异步”。难道不是一次只有一件事可以使用它吗？

使用pthreads,如何在C中初始化静态的互斥量数组？

对于单个静态互斥锁,似乎我可以使用PTHREAD_MUTEX_INITIALIZER.但是它们的静态数组呢？例如,在

#include <pthread.h>
#define NUM_THREADS 5

/*initialize static mutex array*/
static pthread_mutex_t mutexes[NUM_THREADS] = ...?

或者必须动态分配？

非二进制的..
我从未遇到过要求我使用信号量而不是互斥量的问题.那么这主要是理论上的构造,还是像Office这样的真实流行,Firefox有哪些地方可以使用它？如果是这样,信号量的常用模式是什么？