C++ 搜索并发链表

我有一个并发的链表。我需要对该列表中的查找进行优先级排序，因此，如果某个线程开始在该列表上迭代，并且出现后续的插入/删除请求，我希望对这些请求进行排队，但如果有来自其他线程的查找请求，我会让它们发生。实施这种情况的最佳方式是什么

---

编辑：我不想复制列表。太贵了。妈妈为我的硬件买单。

听起来你好像在找一台电脑。这是一个锁，可用于让多个线程读取数据结构，但当一个线程具有写访问权限时，所有其他线程都被锁定

---

Boost提供了一个新的解决方案。

听起来您正在寻找一个新的解决方案。这是一个锁，可用于让多个线程读取数据结构，但当一个线程具有写访问权限时，所有其他线程都被锁定

Boost提供了一个解决方案。

您在Windows上吗？ 如果是这样，您可以使用事件或互斥体之类的同步对象

对于insert和delete，您可以在这些函数的开头锁定互斥体，并在函数的结尾释放互斥体

步骤如下所示

创建事件对象

在插入/删除函数的开头使用WaitForSingleObject函数锁定事件对象。

使用SetEvent在insert/delete函数结束时解锁事件对象，这样等待此事件对象的线程将获得执行插入/删除操作的机会。

读取不需要获取锁。因此，读取时不需要事件或互斥。多个线程可以从共享缓冲区并发读取

有关读写器锁的一般信息，请访问

您可以在以下网址获得示例程序： 你在Windows上吗？ 如果是这样，您可以使用事件或互斥体之类的同步对象

对于insert和delete，您可以在这些函数的开头锁定互斥体，并在函数的结尾释放互斥体

步骤如下所示

创建事件对象

在插入/删除函数的开头使用WaitForSingleObject函数锁定事件对象。

使用SetEvent在insert/delete函数结束时解锁事件对象，这样等待此事件对象的线程将获得执行插入/删除操作的机会。

读取不需要获取锁。因此，读取时不需要事件或互斥。多个线程可以从共享缓冲区并发读取

有关读写器锁的一般信息，请访问

您可以在以下网址获得示例程序：

---

听起来像是一个普通的读写器锁并不是你想要的。一旦您尝试获取锁的写入端，更多的读卡器将阻塞，直到写入器完成，而您说您希望执行读操作的其他线程获得访问权限，即使存在挂起的插入

我不确定你想要的东西是否安全。如果有足够的读取正在进行，则插入/删除操作可能会永远被阻止

如果您真的想要这个，您可以自己轻松地构建它，就像您可以轻松地在标准互斥锁之上构建读写器锁一样

请注意，此代码可能已被破坏，但它可能会为您提供一个总体概念

class UnfairReaderWriterMutex {
  Mutex mutex;
  CondVar condition;
  int readers;  // if positive, reader count; if -1, writer lock is held
 public:
  UnfairReaderWriterMutex() : counter(0) { }
  void ReaderLock() {
    mutex.Lock();
    while (counter < 0) {
      condition.Wait();
    }
    ++readers;
    mutex.Unlock();
  }
  void ReaderUnlock() {
    mutex.Lock();
    assert(readers > 0);
    --readers;
    condition.Notify();  // only need to wake up one writer
    mutex.Unlock();
  }
  void WriterLock() {
    mutex.Lock();
    while (counter > 0) {
      condition.Wait();
    }
    readers = -1;
    mutex.Unlock();
  }
  void WriterUnlock() {
    mutex.Lock();
    assert(readers == -1);
    readers = 0;
    condition.NotifyAll();  // there may be multiple readers waiting
    mutex.Unlock();
  }
};

类UnfairReaderWriterMutex{
互斥互斥；
康瓦尔条件；
int readers；//如果为正，则为读卡器计数；如果为-1，则为保持writer锁
公众：
UnderReaderWriterMutex（）：计数器（0）{}
void ReaderLock（）{
mutex.Lock（）；
while（计数器<0）{
条件。等待（）；
}
++读者；
mutex.Unlock（）；
}
void ReaderUnlock（）{
mutex.Lock（）；
断言（读卡器>0）；
--读者；
condition.Notify（）；//只需要唤醒一个编写器
mutex.Unlock（）；
}
void WriterLock（）{
mutex.Lock（）；
而（计数器>0）{
条件。等待（）；
}
读者=-1；
mutex.Unlock（）；
}
void WriterUnlock（）{
mutex.Lock（）；
断言（读卡器==-1）；
读者=0；
condition.NotifyAll（）；//可能有多个读卡器正在等待
mutex.Unlock（）；
}
};

---

典型的读写器锁的工作原理与此类似，只是有一个标志阻止读写器在有写入器等待时获取锁。

听起来普通的读写器锁并不是您想要的。一旦您尝试获取锁的写入端，更多的读卡器将阻塞，直到写入器完成，而您说您希望执行读操作的其他线程获得访问权限，即使存在挂起的插入

我不确定你想要的东西是否安全。如果有足够的读取正在进行，则插入/删除操作可能会永远被阻止

如果您真的想要这个，您可以自己轻松地构建它，就像您可以轻松地在标准互斥锁之上构建读写器锁一样

请注意，此代码可能已被破坏，但它可能会为您提供一个总体概念

class UnfairReaderWriterMutex {
  Mutex mutex;
  CondVar condition;
  int readers;  // if positive, reader count; if -1, writer lock is held
 public:
  UnfairReaderWriterMutex() : counter(0) { }
  void ReaderLock() {
    mutex.Lock();
    while (counter < 0) {
      condition.Wait();
    }
    ++readers;
    mutex.Unlock();
  }
  void ReaderUnlock() {
    mutex.Lock();
    assert(readers > 0);
    --readers;
    condition.Notify();  // only need to wake up one writer
    mutex.Unlock();
  }
  void WriterLock() {
    mutex.Lock();
    while (counter > 0) {
      condition.Wait();
    }
    readers = -1;
    mutex.Unlock();
  }
  void WriterUnlock() {
    mutex.Lock();
    assert(readers == -1);
    readers = 0;
    condition.NotifyAll();  // there may be multiple readers waiting
    mutex.Unlock();
  }
};

类UnfairReaderWriterMutex{
互斥互斥；
康瓦尔条件；
int readers；//如果为正，则为读卡器计数；如果为-1，则为保持writer锁
公众：
UnderReaderWriterMutex（）：计数器（0）{}
void ReaderLock（）{
mutex.Lock（）；
while（计数器<0）{
条件。等待（）；
}
++读者；
mutex.Unlock（）；
}
void ReaderUnlock（）{
mutex.Lock（）；
断言（读卡器>0）；
--读者；
condition.Notify（）；//只需要唤醒一个编写器
mutex.Unlock（）；
}
void WriterLock（）{
mutex.Lock（）；
而（计数器>0）{
条件。等待（）；
}
读者=-1；
mutex.Unlock（）；
}
void WriterUnlock（）{
mutex.Lock（）；
断言（读卡器==-1）；
读者=0；
condition.NotifyAll（）；//可能有多个读卡器正在等待
mutex.Unlock（）；
}
};

---

典型的读写器锁的工作原理与此类似，只是有一个标志阻止读写器在有写写器等待时获取锁。

妈妈为我的硬件付费。。。什么没有人觉得这个额外的细节像我一样幽默？妈妈为我的硬件买单。。。没有人认为这个额外的细节是哼哼