标签: mutex

如何判断我的程序的一个实例是否正在运行？我以为我可以用数据文件做这个但它只是凌乱:(

我想这样做,因为我只希望一个实例在一个点上打开.

如果我锁定std::mutex遗嘱,我总会得到一个记忆围栏？我不确定它是暗示还是强迫你获得围栏.

更新:

根据RMF的评论发现此参考文献.

多线程编程和内存可见性

我有一个应用程序,其中2个线程正在运行...当我从一个线程更改一个全局变量时,是否有任何证据,另一个会注意到这个变化？我没有任何同步或互斥系统......但是这段代码应该一直工作(想象一下名为dataUpdated的全局bool):

线程1:

while(1) {
    if (dataUpdated)
        updateScreen();
    doSomethingElse();
}

线程2:

while(1) {
    if (doSomething())
        dataUpdated = TRUE;
}

像gcc这样的编译器是否以不检查全局值的方式优化此代码,只在编译时考虑它的值(因为它会在同一个thred中更改)？

PS:对于类似游戏的应用程序而言,在写入值时是否会有读取真的无关紧要......重要的是这个更改会被其他线程注意到.

我有一个C++应用程序,它由非托管C++,托管C++和c#组成.在非托管部分,我正在尝试使用std :: mutex创建一个线程安全集合.

但是,当我使用互斥锁时,我收到以下错误;

错误C1189:使用/ clr或/ clr:pure进行编译时不支持#error:<mutex>.

知道为什么我不能使用互斥锁吗？有人可以推荐替换它,以便我可以创建一个线程安全的非托管集合吗？

所以我刚刚意识到PHP可能同时运行多个请求.昨晚的日志似乎显示有两个请求进入,并行处理; 每个触发从另一个服务器导入数据; 每个都试图将记录插入数据库.当它试图插入另一个线程刚刚插入一条记录的一个请求失败(导入的数据自带的PK,我没有使用递增的ID): SQLSTATE[23000]: Integrity constraint violation: 1062 Duplicate entry '865020' for key 'PRIMARY' ....

1. 我是否正确诊断了此问题？
2. 我该如何解决这个问题？

以下是一些代码.我已经删除了大部分内容(日志记录,从数据中创建患者以外的其他实体),但以下内容应包括相关的代码段.请求命中了import()方法,该方法基本上为每个要导入的记录调用importOne().注意importOne()中的save方法; 这是一个Eloquent方法(使用Laravel和Eloquent),它将生成SQL以适当地插入/更新记录.

public function import()
{
        $now = Carbon::now();
        // Get data from the other server in the time range from last import to current import
        $calls = $this->getCalls($this->getLastImport(), $now);
        // For each call to import, insert it into the DB (or update if it already exists)
        foreach ($calls as $call) {
            $this->importOne($call);
        }
        // Update the last import time to now …

做一些事情是否有意义,例如放入一个std::lock_guard额外的范围,以便锁定时间尽可能短？

伪代码:

// all used variables beside the lock_guard are created and initialized somewhere else
...// do something

{ // open new scope
    std::lock_guard<std::mutex> lock(mut);
    shared_var = newValue;  
} // close the scope

... // do some other stuff (that might take longer)

除了锁定持续时间短之外还有其他优点吗？

什么可能是负面影响？

我试着寻找这方面的细节,我甚至阅读了关于互斥和原子的标准......但我仍然无法理解C++ 11内存模型的可见性保证.据我所知,互斥BESIDE互斥的一个非常重要的特点是确保可见性.Aka每次只有一个线程增加计数器是不够的,重要的是线程增加了最后使用互斥锁的线程所存储的计数器(我真的不知道为什么人们在讨论时不再提这个互斥,也许我有坏老师:)).所以从我可以告诉原子并不强制立即可见性:(来自维护boost :: thread并已实现c ++ 11线程和互斥库的人):

具有memory_order_seq_cst的fence不会强制立即查看其他线程(并且MFENCE指令也不会).C++ 0x内存排序约束只是---排序约束.memory_order_seq_cst操作形成一个总顺序,但对该顺序没有任何限制,除了它必须由所有线程达成一致,并且它不得违反其他排序约束.特别是,如果线程按照与约束一致的顺序看到值,则线程可能会在一段时间内继续看到"陈旧"值.

而且我很好.但问题在于我无法理解C++ 11关于原子的构造是"全局的",而且只能确保原子变量的一致性.特别是我了解以下内存排序中的哪些(如果有的话)保证在加载和存储之前和之后将有一个内存栅栏:http: //www.stdthread.co.uk/doc/headers/atomic/memory_order. HTML

从我可以告诉std :: memory_order_seq_cst插入mem屏障,而其他只强制执行某些内存位置上的操作的顺序.

所以有人可以清楚这一点,我认为很多人会使用std :: atomic制作可怕的错误,如果他们不使用默认值(例如std :: memory_order_seq_cst内存排序),
那么就是2.如果我是对的,那就意味着第二行是此代码中的冗余:

atomicVar.store(42);
std::atomic_thread_fence(std::memory_order_seq_cst);  

3. std :: atomic_thread_fences在某种意义上与互斥量具有相同的要求,为了确保非原子变量的seq一致性,必须执行std :: atomic_thread_fence(std :: memory_order_seq_cst); 在load和std :: atomic_thread_fence(std :: memory_order_seq_cst)之前;
经过商店？
是的

  {
    regularSum+=atomicVar.load();
    regularVar1++;
    regularVar2++;
    }
    //...
    {
    regularVar1++;
    regularVar2++;
    atomicVar.store(74656);
  }

相当于

std::mutex mtx;
{
   std::unique_lock<std::mutex> ul(mtx);
   sum+=nowRegularVar;
   regularVar++;
   regularVar2++;
}
//..
{
   std::unique_lock<std::mutex> ul(mtx);
    regularVar1++;
    regularVar2++;
    nowRegularVar=(74656);
}

我想不是,但我想确定.

编辑:5.可以断言？
只存在两个线程.

atomic<int*> p=nullptr; 

第一个线程写

{
    nonatomic_p=(int*) malloc(16*1024*sizeof(int));
    for(int i=0;i<16*1024;++i) …

我读到互斥锁是一个值为1(二进制信号量)的信号量,用于强制互斥.

我读到了这个链接 Semaphore vs. Monitors - 有什么区别？ 这表明监视器有助于实现互斥.

任何人都可以告诉我互斥和监视器之间的区别,因为两者实际上都在做同样的事情

有没有一种方法,我可以告诉std::lock_gaurd打电话try_lock,而不是lock当它获取该互斥锁？

我能想到的唯一方法是使用std::adopt_lock:

if (!_mutex.try_lock())
{
    // Handle failure and return from the function
}
std::lock_guard<my_mutex_class> lock(_mutex, std::adopt_lock);

是否有针对我的问题的内置解决方案,而不是明确获取锁定,然后lock_guard负责释放它？

如果解锁已解锁的互斥锁,行为是不安全,安全还是未定义？

问题的目的与下面的代码有关,我不知道在if块中解锁互斥锁是否更好,或者只是在if块之外.

    // This chunk of code makes dual locking semi-autonomous.
    int c_lckd = 0, q_lckd = 0;
    if (pthread_mutex_trylock(&crunch_mutex) == 0) c_lckd = 1;
    if (pthread_mutex_trylock(&queue_mutex) == 0) q_lckd = 1;
    if (q_lckd && !c_lckd) { QUEUE_UNLOCK; q_lckd = 0; }
    else if (c_lckd && !q_lckd) { CRUNCH_UNLOCK; c_lckd = 0; }

    if (c_lckd && q_lckd) {
      printf("cr = %d, max = %d, cnt = %d\n",
        crunching, max_crunching, queue_count(conn_queue));
      if (crunching < max_crunching && queue_count(conn_queue)) {
        pthread_t tid = …