标签: mutual-exclusion

如果你在一个应用程序中有两个线程,并且你不希望它们同时运行某段代码,你就可以锁定这段代码,如下所示:

lock (someObject) {
    // ... some code
}

但是你如何在不同的流程中做同样的事情呢？我认为这是你使用"全局互斥"的原因,所以我Mutex以各种方式尝试了这个类,但它似乎不符合我的要求,它们是:

• 如果您是唯一的实例,请继续运行代码.
• 如果您是第二个实例,请等待第一个实例完成,然后运行代码.
• 不要抛出异常.

我遇到的问题:

• 只是Mutex在using(){...}子句中实例化一个对象似乎没有做任何事情; 两个实例仍然愉快地同时运行
• 调用.WaitOne()互斥锁导致第一个实例运行而第二个实例等待,但第二个实例无限期等待,即使在第一次调用.ReleaseMutex()并离开using(){}范围之后也是如此.
• .WaitOne()当第一个进程退出(System.Threading.AbandonedMutexException)时抛出异常.

我该如何解决这个问题？不涉及的解决方案Mutex非常受欢迎,特别是因为它Mutex似乎是特定于Windows的.

我是旋转模型检查的新手,想知道这个错误意味着什么:

unreached in proctype P1
    ex2.pml:16, state 11, "-end-"
    (1 of 11 states)
unreached in proctype P2
    ex2.pml:29, state 11, "-end-"
    (1 of 11 states)

这是我的代码:

int y1, y2;
byte insideCritical;

active proctype P1(){
do
    ::true->
        y2 = y1 + 1;
        (y1 == 0 || y2 < y1);
        /* Entering critical section */
            insideCritical++;
            assert(insideCritical < 2);
            insideCritical--;
        /* Exiting critical section */
        y2 = 0;
od
}
active proctype P2(){
do
    ::true->
        y1 = y2 + 1;
        (y2 == …

这是用软件编写的测试和设置:

boolean TestAndSet(boolean *target) {
    boolean rv = *target;
    *target = TRUE;
    return rv;
}

和

do {
    while(TestAndSetLock(&lock))
        ; // do nothing
        // critical section
    lock = FALSE;
        // remainder section
} while(TRUE);

我们可以在CPU中使用不支持硬件级别的测试和设置的机制吗？如果是这样,原子性如何得到保证？

我正在阅读着名的操作系统概念书(Avi Silberschatz,Peter Baer Galvin,Greg Gagne)第9版:http://codex.cs.yale.edu/avi/os-book/OS9/

在进程同步章节中,有一个"Bounded-waiting Mutual Exclusion with test_and_set"的算法如下:

do {
    waiting[i] = true;
    key = true;  // <-- Boolean variable that I do not see its utility
    while (waiting[i] && key) // <-- the value of the key variable here is always true
        key = test_and_set(&lock); // <-- it might become false here, but what is the point?
    waiting[i] = false;

    /* critical section */

    j = (i + 1) % n;
    while ((j != …

我有一个 Python 类，它需要接受两个互斥参数之一。如果参数不是排他性的（即：如果两者都给出或都不给出），则应引发错误。

class OrgLocation:
    __init__(self, location_num=None, location_path=None):
        """location_num & location_path are mutually exclusive"""

在大多数情况下，最好的选择是创建两个单独的类。但是，我正在使用一个外部 API，它要求这两个属性相互排斥。

要求：

<OrgLocation LocationPathName="ROOT/BU/DIV/SL/DEPT/JOB" LocationNum="1234"/>

回复：

<Error Message="Use either LocationNum or LocationPathName but not both." ErrorCode="1186">

类似的问题似乎表明argparse可用于命令行界面中的互斥参数，但我不确定如何将其应用于类构造函数

如何创建具有互斥参数的 Python 函数？

我需要为这种情况解决锁定问题:

1. 一个多CPU系统.
2. 所有CPU都使用通用(软件)资源.
3. 只读访问资源非常常见.(传入网络数据包的处理)
4. 写访问频率低得多.(仅限配置更改).

目前我使用的read_lock_bh,write_lock_bh(自旋锁)机制.问题是CPU越多,我在编写器上下文中获得的软锁定就越多.

我阅读了本书中的并发章节,但是在使用自旋锁时,无法理解读者或作者是否会获得优先权.

所以问题是:

1. Linux自旋锁机制是否优先考虑读者/作者/没有人？
2. 有没有一种更好的机制可以用来避免我的场景中的那些软锁定,或者在使用我当前的解决方案时,可能是一种让我在编写器获得锁定时优先考虑的方法？

谢谢,Nir

我的表有两列:

1. startsAt
2. endsAt

两者都保持日期和时间.我想制定以下约束:

如果两列都不是NULL,则startsAt和endsAt之间的范围不得与其他范围(来自其他行)重叠.

我对pthread函数pthread_rwlock_wrlock的行为有疑问。上面链接的规范指出，当一个线程锁定了写锁并且同一线程再次将其锁定时，将导致未定义的行为（我实际上可以观察到这一点，因为在x86 Linux上，调用此函数是noop，而在PowerPC Linux上，停止线程）。

我需要的行为是具有以下特征的读写锁：

• 在以下情况下，线程读取锁定成功：
  • 锁不由任何线程持有
  • 该锁仅由零个或多个线程（包括调用线程）进行读锁定，并且可能被调用线程进行读或写锁定
• 在以下情况下，写锁定成功：
  • 该锁不由任何其他线程持有
  • 仅当前线程持有该锁（用于读取或写入）

使用a时pthread_mutex_t，可以通过初始化标志来控制锁的递归性，但是对于，这是不可能的pthread_rwlock_t。

我有什么选择？实际上，我从来没有必须在C中实现这种并发原语，而且我想这里缺少一些明显的解决方案。

我分别如下定义互斥和死锁:如果每个时刻,每个共享资源被分配给一个进程或者可用,则存在互斥条件.如果集合中的每个进程都在等待集合中只有另一个进程可能导致的事件,则一组进程将死锁.

比如,使用二进制信号量,确保其中只有一个可以同时进入其关键区域.由于每个流程在进入其关键区域之前都会向下运行,而在离开之后向上运行,因此可以保证互斥.

我知道有四个条件必须都能解决死锁,其中一个是互斥条件(在它们的关键部分中没有两个进程可以同时进行).

由于相互排斥得到保证,在这种情况下,程序是否无死锁？

问候.

我正在查看 pthreadtypes.h 文件中的 pthread_mutex_t 结构。“__lock”代表什么？它就像分配给互斥锁的锁号吗？

typedef union
{
  struct __pthread_mutex_s
  {
     int __lock;
     unsigned int __count;
     int __owner;
     #if __WORDSIZE == 64
     unsigned int __nusers;
     #endif
    /* KIND must stay at this position in the structure to maintain
     binary compatibility.  */
     int __kind;
     #if __WORDSIZE == 64
     int __spins;
     __pthread_list_t __list;
     # define __PTHREAD_MUTEX_HAVE_PREV 1
     #else
     unsigned int __nusers;
     __extension__ union
    {
      int __spins;
      __pthread_slist_t __list;
    };
    #endif
  } __data;
 char __size[__SIZEOF_PTHREAD_MUTEX_T];
 long int __align;

pthread_mutex_t;