如何在不使用互斥锁，半变量，spinLock和futex的情况下进行线程同步？

Question

这是一个面试问题，面试已经完成。

如何在不使用互斥锁，半变量，spinLock和futex的情况下进行线程同步？

给定5个线程，如何使4个线程在同一点等待来自左线程的信号？ 这意味着当所有线程（1,2,3,4）在其线程函数中的某个点执行时，它们会停止并等待来自线程5的信号发送信号，否则它们将不会继续。

我的点子：

使用全局bool变量作为标志，如果线程5未将其设置为true，则所有其他线程在一个点等待，并将其标志变量设置为true。 在线程5发现所有线程的标志变量都为真之后，它将设置标志var true。

这是一个忙碌的等待。

有更好的想法吗？

谢谢

 the pseudo code:
 bool globalflag = false; 
 bool a[10] = {false} ;  
 int main()
 {
  for (int i = 0 ; i < 10; i++)
  pthread_create( threadfunc, i ) ; 

      while(1)
      {
         bool b = true; 
         for (int i = 0 ; i < 10 ; i++)
         {  
              b = a[i] & b ; 
         }
         if (b) break; 
    }
  }
  void threadfunc(i)
  {
   a[i] = true; 
   while(!globalflag); 
  }

Answer 1

从等待线程的空链表开始。 头应设置为0。

使用CAS，比较和交换，在服务员列表的头部插入一个线程。 如果head = -1，则不要插入或等待。 如果你做得对，你可以安全地使用CAS在链表的头部插入项目。

插入后，等待线程应该等待SIGUSR1。 使用sigwait（）来执行此操作。

准备就绪后，信令线程使用CAS将等待列表的头部设置为-1。 这可以防止更多线程将自己添加到等待列表中。 然后信令线程迭代等待列表中的线程并调用pthread_kill（＆thread，SIGUSR1）来唤醒每个等待的线程。

如果在调用sigwait之前发送SIGUSR1，则sigwait将立即返回。 因此，在向等待列表添加线程和调用sigwait之间不会有竞争。

编辑：

为什么CAS比互斥锁更快？ Laymen的回答（我是一个门外汉）。 在某些情况下，某些事情会更快，因为在没有比赛时它的开销较低。 因此，如果您可以将并发问题减少到需要更改8-16-32-64-128位的连续内存，并且竞争不会经常发生，则CAS获胜。 CAS基本上是一个稍微花哨/昂贵的mov指令，无论如何你要去做一个普通的“mov”。 它是一个“锁定exchng”或类似的东西。

另一方面，互斥体是一大堆额外的东西，它会使其他缓存线变脏并使用更多的内存屏障等。虽然CAS在x86，x64等上充当内存屏障。当然，你必须解锁互斥量可能大约相同数量的额外东西。

以下是使用CAS将项目添加到链接列表的方法：

while (1)
{
  pOldHead = pHead;  <-- snapshot of the world.  Start of the race.
  pItem->pNext = pHead;
  if (CAS(&pHead, pOldHead, pItem))  <-- end of the race if phead still is pOldHead
    break; // success
}

那么您认为您的代码在同一时间在该CAS行上有多个线程的频率是多少？ 实际上......并不常见。 我们做了一些测试，只是循环添加数百万个具有多个线程的项目，并且发生的时间不到1％。 在真正的程序中，它可能永远不会发生。

显然，如果有比赛，你必须回去再次进行循环，但是在链接列表的情况下，这会花费你多少钱？

缺点是，如果要使用该方法将项目添加到头部，则无法对该链接列表执行非常复杂的操作。 尝试实现双链表。 太痛苦了。

编辑：

在上面的代码中，我使用宏CAS。 如果你使用linux，CAS =宏使用__sync_bool_compare_and_swap。 请参阅gcc atomic builtins 。 如果您使用的是Windows，则CAS =使用InterlockedCompareExchange之类的宏。 以下是Windows中的内联函数的外观：

inline bool CAS(volatile WORD* p, const WORD nOld, const WORD nNew) { 
  return InterlockedCompareExchange16((short*)p, nNew, nOld) == nOld; 
}
inline bool CAS(volatile DWORD* p, const DWORD nOld, const DWORD nNew) {
  return InterlockedCompareExchange((long*)p, nNew, nOld) == nOld; 
}
inline bool CAS(volatile QWORD* p, const QWORD nOld, const QWORD nNew) {
  return InterlockedCompareExchange64((LONGLONG*)p, nNew, nOld) == nOld; 
}
inline bool CAS(void*volatile* p, const void* pOld, const void* pNew) {
  return InterlockedCompareExchangePointer(p, (PVOID)pNew, (PVOID)pOld) == pOld; 
}

Answer 2

1. 选择要使用的信号，比如SIGUSR1。
2. 使用pthread_sigmask阻止SIGUSR1。
3. 创建线程（它们继承信号掩码，因此必须先完成1！）
4. 线程1-4调用sigwait，阻塞直到收到SIGUSR1。
5. 线程5使用SIGUSR1调用kill（）或pthread_kill 4次。 由于POSIX指定将信号传递给未阻塞信号的线程，因此它将被传递给在sigwait（）中等待的其中一个线程。 因此，不需要跟踪哪些线程已经接收到信号，哪些线程没有接收到相关的同步。

Answer 3

您可以使用SSE3的MONITOR和MWAIT指令，通过_mm_mwait和_mm_monitor内在函数提供，英特尔在这里有一篇文章。 （还有一项使用内存监视器的专利 - 等待这里可能感兴趣的锁争用）。

Answer 4

我想你正在寻找Peterson的算法或Dekker的算法

它们仅基于共享内存同步线程