使动态数组线程安全且并发是什么意思？比如说,std::vector.
那么有什么需要做的std::vector才能使它成为线程安全和并发的,或者它是默认的线程安全和并发的吗？
我正在尝试编写一个用于消息传递的无锁版本的调用队列.这不是任何严肃的事情,只是为了了解线程.
我相对确定我的代码是正确的,除非指令被重新排序或在寄存器中完成.我知道我可以使用内存屏障来停止重新排序,但是如何确保将值立即写入内存？
Public Class CallQueue
Private first As New Node(Nothing) 'owned by consumer'
Private last As Node = first 'owned by producers'
Private Class Node
Public ReadOnly action As Action
Public [next] As Node
Public Sub New(ByVal action As Action)
Me.action = action
End Sub
End Class
Private _running As Integer
Private Function TryAcquireConsumer() As Boolean
Threading.Thread.MemoryBarrier()
'Dont bother acquiring if there are no items to consume'
'This unsafe check is alright because enqueuers call this method, so we never …我发现了以下文章:使用GCC提供的原子锁操作来替换pthread_mutex_lock函数
它指的是GCC Atomic Builtins.
本文的建议是使用GCC原子内置而不是pthread同步工具.
这是一个好主意吗？
PS.mysql帖子显然具有误导性.Atomic Builtins无法替换所有pthread工具.例如,锁定要求,如果无法获取锁,则线程必须等待.换句话说,它要求操作系统等待,以便等待是被动的.简单的GCC内置无法做到这一点.
我正在寻找关于各种英特尔处理器的锁定cmpxchg指令的平均延迟的一些参考.我无法找到关于该主题的任何好的参考,任何参考都会有很大帮助.
谢谢.
以下是使用compareAndSet(在Java中)的无锁队列中的一些代码:
public void enq(T value) {
Node newNode = new Node(value);
while(true) {
Node last = tail.get();
Node next = last.next.get();
if(last != tail.get())
continue; //???
if (next != null) { //improve tail
tail.compareAndSet(last, next);
continue;
}
if (last.next.compareAndSet(null, newNode)) { //update last node
tail.compareAndSet(last, newNode); //update tail
return;
}
}
}
public T deq() throws EmptyException {
while(true) {
Node first = head.get();
Node last = tail.get();
Node next = first.next.get();
if(first != head.get())
continue; //???
if(first == last) …我在C中寻找具有以下特征的环形缓冲区实现(或伪代码):
到目前为止,我一直只使用SPSC缓冲区 - 每个生产者一个 - 但我想避免消费者不断旋转以检查所有输入缓冲区的新数据(也许是为了摆脱我的一些编组线程)系统).
我在Intel机器上开发Linux.
c multithreading producer-consumer circular-buffer lock-free
用这样的块替换互斥锁具有什么意义呢
void stack_push(stack* s, node* n)
{
node* head;
do
{
head = s->head;
n->next = head;
}
while ( ! atomic_compare_exchange(s->head, head, n));
}
无法理解通过用这种原子替换来替换互斥锁可以获得什么好处？
如果T是 C++ 基本类型，并且如果std::atomic<T>::is_lock_free()返回true，那么是否有任何东西std::atomic<T>是无等待的（不仅仅是无锁的）？像, load, store, fetch_add, fetch_sub, compare_exchange_weak, 和compare_exchange_strong。
您是否还可以根据 C++ 标准中指定的内容以及 Clang 和/或 GCC（您选择的版本）中实现的内容进行回答。
我最喜欢的无锁和无等待定义来自C++ Concurrency in Action（免费提供）。如果满足下面的第一个条件，则算法是无锁的，如果满足以下两个条件，则是无等待的：
我想编写一个一次只能由一个线程访问的函数。我不需要忙碌的等待，如果另一个线程已经在运行它，那么残酷的“拒绝”就足够了。这是我到目前为止想出的：
std::atomic<bool> busy (false);
bool func()
{
if (m_busy.exchange(true) == true)
return false;
// ... do stuff ...
m_busy.exchange(false);
return true;
}
std::memory_order_acq_rel？据我了解，宽松的排序 ( std::memory_order_relaxed) 不足以防止重新排序。我有以下代码：
#include <atomic>
int main () {
std::atomic<uint32_t> value(0);
value.fetch_add(1, std::memory_order::relaxed);
static_assert(std::atomic<uint32_t>::is_always_lock_free);
return 0;
}
它可以编译，所以这意味着std::atomic<uint32_t>::is_always_lock_free是真的。
然后，使用 gcc 10 和 的汇编代码如下所示-std=c++20 -O3 -mtune=skylake-avx512 -march=skylake-avx512：
0000000000401050 <main>:
401050: c7 44 24 fc 00 00 00 mov DWORD PTR [rsp-0x4],0x0
401057: 00
401058: f0 ff 44 24 fc lock inc DWORD PTR [rsp-0x4]
40105d: 31 c0 xor eax,eax
40105f: c3 ret
许多帖子指出，读-修改-写操作（fetch_add()此处）不能是没有锁的原子操作。
我的问题是std::atomic::is_always_lock_free存在的true真正含义是什么。
该页面说明Equals true if this atomic type is …