2回答
在一些关于算法的文章中，有些使用了单词lockfree，有些使用了lockless。lockless和lockfree有什么区别？谢谢!
更新
第5.2节--“Linux中的无锁环缓冲区*”，这是使用单词“无锁”的一个例子
浏览 0提问于2013-12-09得票数 12
回答已采纳
3回答
如何实施ABA解决方案？
、、、、
我正在尝试从实现Michael-Scott FIFO队列。我无法实现他们对ABA问题的解决方案。我得到了这个错误。
error: incompatible type for argument 1 of '__sync_val_compare_and_swap'
作为参考，我使用linux机器在英特尔架构上编译这段代码。如果您需要更多关于我的设置的信息，请联系我。
sync_val_CAS似乎只能处理最多32位的值。因此，当我删除用于消除ABA问题的计数器时，一切都编译并运行良好。
有人知道我应该在这里使用的相关64位CAS指令吗？
另一个问题是，是否有更好(更快)的无锁fifo
浏览 8提问于2012-06-06得票数 0
1回答
我想在两个pthread之间实现一个无锁的单生产者、单消费者循环队列；用C语言，在ARM Linux上。
队列将保存字节，生产者将memcpy()内容放入，消费者将它们写出到文件中。
认为我可以在int中存储头部和尾部偏移量，然后一切都会正常工作，这是不是很天真？我想知道编译器优化意味着我的头/尾写位于寄存器中，对其他线程不可见，或者需要在某个地方设置内存屏障。
浏览 48提问于2011-06-23得票数 1
回答已采纳
我有一个p线程应用程序，我目前使用常规linux管道来通信，并向不同的线程发送消息。它的工作很好，并没有真的坏，但我有一种唠叨的感觉，它可以改进。
如果我想设计最小的延迟，那么最快的方法是什么呢？使用条件变量会比管道更快吗？
我需要传递少量的数据，作为一个带几个参数的独立的optcode。线程条件变量允许我在线程之间传递数据吗？
谢谢,
-Andres
浏览 0提问于2012-12-10得票数 1
回答已采纳
5回答
循环缓冲区队列中的无锁进度保证
、、、、
有趣的是，我发现很多程序员错误地认为“无锁”仅仅意味着“没有互斥的并发编程”。通常，还有一个相关的误解，即编写无锁代码的目的是为了获得更好的并发性能。当然，无锁的正确定义实际上是关于进度保证的。无锁算法保证至少有一个线程能够向前推进，而不管其他线程在做什么。
这意味着没有锁的算法永远不会有一个线程依赖另一个线程来继续执行的代码。例如，无锁代码不能出现线程A设置标志的情况，然后线程B在等待线程A取消设置标志时继续循环。这样的代码基本上是实现了一个锁(或者我称之为伪装的互斥)。
然而，有些情况更微妙，有些情况下我真的无法判断算法是否符合无锁的条件，因为“取得进展”的概念有时对我来说是主观的。
其中
浏览 3提问于2017-08-27得票数 30
回答已采纳
1回答
我使用Boost的无锁队列作为生产者-消费者队列。我希望每个使用者线程在队列为空时阻塞，当队列中有更多数据时醒来，或者任何生产者终止。但是Boost似乎没有提供阻塞的pop，只提供立即返回的pop。
消费者应如何等待数据可用？
浏览 1提问于2015-04-12得票数 2
回答已采纳
我比较了这三种情况的运行时间，它们是boost::lockfree::queue，boost::lockfree::spsc_queue，以及使用std::queue的生产者/消费者队列的序列码。我编译并运行了"/apps/ boost _1_56_0/libs/lockfree/examples“中的"spsc_queue.cpp”和"queue.cpp“boost示例代码，下面是生成/使用相同数量的对象的序列代码。
boost::lockfree::queue产生/消费400000000个对象所花费的时间是290秒，而boost::lockfree::spsc_qu
浏览 1提问于2015-04-16得票数 1
2回答
在iTron中，有较轻版本的消息队列称为数据队列。它们非常容易用于快速消息传输。Linux中是否存在任何等价的同步原语？
数据队列的定义:它是一个单词消息()的队列。
浏览 2提问于2009-04-10得票数 1
回答已采纳
1回答
目前我们有LinkedBlockingQueue和ConcurrentLinkedQueue。
LinkedBlockingQueue可以是有界的，但它使用锁。
ConcurrentLinkedQueue不使用锁，但它不是有界的。而且它不会阻塞，这使得它很难轮询。
显然，我不能让一个既阻塞又无锁的队列(等待自由或非阻塞或其他)。我不要求学术上的定义。
有没有人知道一个队列实现，它基本上是无锁的(不在热路径中使用锁)，在空的时候阻塞(不需要忙碌等待)，并且是有界的(满的时候阻塞)？堆外解决方案也是受欢迎的。
我听说过LMAX Disruptor，但它看起来一点也不像队列。
我也很高兴知道非通用的
浏览 0提问于2017-09-29得票数 3
1回答
或者仅仅是对用法的误解？
、、、、
我正在维护一个用C++编写的多线程的linux服务器应用程序。这里大约有10个模块和数十个std::deques用于消息传递。该应用程序使用生产者-消费者模式在模块之间传递网络数据包。
生产者-消费者设计模式在许多情况下都表现良好，但我不认为它适合我们的应用程序。请看下面的伪代码流程图：
CSocketModule (for receiving and sending packets)
CSockMod::ReceivePackWorkerThread --> CSockMod::Inque -->
CSockMod::In
浏览 0提问于2013-06-02得票数 0
回答已采纳
3回答
我有很多数据想要传播到许多不同的线程。此数据来自单个线程。消费线程可以同时安全地访问容器。
数据需要每隔1个增量秒(50ms <增量< 1)合并到容器中，在此期间需要锁定消耗线程，但不能阻塞。类似地，当数据生产者想要合并数据时，它应该等待任何读取线程完成(这应该是快速的)，但其他任何人都不应该开始读取，因为更新需要尽快发生。
我在linux上工作(平台特定的解决方案非常好/期望的)，我关心每一毫秒。我应该使用哪种锁定机制，或者有没有更好的模型来解决这个问题？
浏览 1提问于2009-10-13得票数 2
回答已采纳
1回答
我最近正在阅读InnoDB代码，需要在上面写一些代码。我知道在S2PL中，被阻塞的事务将在冲突的事务完成后恢复。但是，我不确定InnoDB如何在阻塞后恢复事务，有没有线程来处理这种工作？非常感谢。
浏览 1提问于2012-06-26得票数 2
3回答
我正在设计一个新的改进的Logger组件(.NET 3.5，C#)。
我想使用一个无锁的实现。
日志事件将从(潜在)多个线程发送，尽管只有一个线程将实际输出到文件/其他存储介质。
本质上，所有的写入器都将其数据排队到某个队列中，由其他进程(LogFileWriter)检索。
这能以无锁的方式实现吗？我在网上找不到直接提到这个问题的地方。
浏览 7提问于2012-01-04得票数 2
回答已采纳
我是一个多线程编程的初学者。
我一直在多线程环境中使用并发类，但突然间我对使用阻塞队列感到好奇。
我认为像ConcurrentHashMap这样的并发类使用锁定。
最近，我碰巧使用了队列，我查看了线程安全队列。所以我知道有BlockingQueue和linkedConcurrentQueue，我研究了这两个队列。
使用锁定，阻塞队列是线程安全的。这就是我想的典型的线程安全方式。
Concurrentqueue通过使用名为CAS的算法处理线程安全。但是，我不知道这个CAS的目标是队列本身还是属于队列的元素。即使多个线程同时轮询并发队列中的元素，它们是否轮询不同的元素？难道没有一种情况是一次投票同
浏览 2提问于2020-07-08得票数 0
回答已采纳
2回答
线程安全优先级队列
、、、
有一个目标是使线程池将支持具有优先级的任务。所以我需要编写一些数据结构来支持线程安全的优先级队列。当然，我们可以编写大锁并使用std::priority_queue。但这并不是很有效。
有一个想法是用并发提取实现二进制堆(每个元素都有自己的自旋锁，并且有一个全局shared_mutex，当我们改变堆大小时它是写锁的，当我们堆节点时是读锁的，当我们交换和比较节点时我们会锁定它们的自旋锁)，但是有很多潜在的死锁能力，我仍然不知道如何避免它们。
有没有什么好的数据结构可以更容易地实现线程安全？或者有没有我可以调查的已经实现的堆？
浏览 1提问于2014-03-05得票数 3
我目前有一个容器，它有两个特性，它允许向它添加对象，同时一个独立的线程不断地使用它的项。这是一种先进先出式的设计。以极高的速度接收物体。下面是容器的代码
std::deque<Some_object*> my_container;
void Container::Add_item(Some_object* obj)
{
try
{
{//Begin Lock
boost::lock_guard<boost::mutex> lock(m
浏览 0提问于2013-08-05得票数 6
3回答
我正试图找到一种方法，在Linux上用C语言用多核处理器编写一个没有锁的IPC应用程序。
让我们假设我有进程1和进程2写入FIFO或共享内存。然后进程3和进程4将从共享内存或FIFO读取。
用无锁算法能做到这一点吗？
非常感谢您的指导。
浏览 0提问于2012-07-20得票数 9
一种方法是锁定，然后检查第一个共享队列的状态，如果空间可用，推送数据，如果没有，则忽略，然后解锁。
然后检查第二个共享队列的状态，如果空间可用，推送数据，如果没有，则忽略，然后解锁。
所以，等等。
在这里，我们将不断地锁定和解锁，以查看共享队列的状态，然后采取相应的行动。
问题：
这种方法的缺点是什么？当然，时间会花在锁定和解锁上。是这样吗？
没有当前方法的缺点，实现相同效果的其他方法有哪些？
浏览 6提问于2015-12-21得票数 0
回答已采纳
3回答
我在C++中实现了多线程共享库(适用于Linux和Windows)。我想在库中添加日志记录机制。库的调用者并不知道这一点。日志文件将是相同的，所以我想知道如果多个进程正在使用我的库并试图打开并登录到同一个日志文件中，我如何设计线程安全日志记录。有什么建议吗？
浏览 1提问于2010-02-09得票数 1
回答已采纳
1回答
隐藏G3Log的实现
、、、
我正在尝试使用G3Log ( Google logger -glog的一个版本)在静态库中做一些日志记录。在我尝试将该静态库放入C++/CLI托管包装器之前，一切都运行得很好。当我这样做的时候，我得到了可怕的问题：
error C1189: #error : <mutex> is not supported when compiling with /clr or /clr:pure.
问题是接收器的回调函数需要g2::LogMessageMover，要做到这一点，我必须带回头文件。那么，如何封装glog.hpp标头，使其对C++/CLI应用程序不可见呢？
这是我尝试过的方法，但我被
浏览 50提问于2015-02-17得票数 2
6回答
我在想，当多个线程正在读或写时，是否可能有一个无锁的队列？我已经看到了一个没有锁队列的实现，它可以处理一个读线程和一个写线程，但两者都不能超过一个。有可能吗？我不认为是这样。有人想证明吗？
浏览 14提问于2010-06-11得票数 9
回答已采纳
在objective中，有(至少)两种方法来同步对共享资源的并发访问。旧的基于锁的方法和使用Grand Central Dispatch (GCD)的更新方法，后者使用dispatch_sync将所有访问分配到共享队列。
在中，有人说“使用锁是要付出代价的，即使在没有争议的情况下，使用锁也会导致性能损失。”
这是GCD方法的有效论据吗？
我认为这不是出于以下原因：
队列必须有要执行的排队任务列表。一个或多个线程可以通过dispatch_sync将任务添加到此列表中，而一个或多个工作线程需要从该列表中删除元素才能执行任务。这必须用锁来保护。所以那里也需要一把锁。
请告诉我，如果有任何其他方式，队
浏览 2提问于2013-09-04得票数 2
回答已采纳
5回答
无锁队列的C代码
、、
如何在C中实现这种无锁队列伪代码
ENQUEUE(x)
q ← new record
q^.value ← x
q^.next ← NULL
repeat
p ← tail
succ ← COMPARE&SWAP(p^.next, NULL, q)
if succ ≠ TRUE
COMPARE&SWAP(tail, p, p^.next)
until succ = TRUE
COMPARE&SWAP(tail,p,q)
end
DEQUEUE()
浏览 0提问于2011-05-23得票数 9
回答已采纳
我想从这个网站运行一个例子46.3的变体。我使用的是linux系统。
我希望在头文件中定义队列Q。我想让产生和消费函数放在不同的文件中。所以我希望global.h包含
static boost::lockfree::queue<int> q{100};
static std::atomic<int> sum{0};
void *produce (void*);
void *consume (void*);
然后，我希望有一个produce.cpp包含：
void *produce( void*)
{
浏览 0提问于2016-10-09得票数 0
1回答
添加到无锁列表的尾部
、、、、
我使用的是llist.h中定义的Linux内核的无锁列表。llist_add添加到列表中，但是它在头后面添加了新节点。如何在固定时间内添加到列表的尾部？
浏览 12提问于2016-08-04得票数 0
回答已采纳
1回答
我有一个使用boost::lockfree::queue的单线程应用程序(来自Boost 1.57)。(我之所以使用队列，是因为它是库的一部分，也用于多线程应用程序中。)
队列似乎在某种程度上丢失了元素。
使用队列的类的行为如下：
有两个单独的函数调用队列中的push。除了队列本身提供的内容之外，没有线程安全逻辑。
有一个函数使用队列中的元素；它使用while(my_queue.pop(temp_element))循环消耗所有元素。此函数由互斥锁保护，以确保所有元素都传递给单个使用者。但是，如果在一行中检测到两个重复元素(与==相比)，则跳过第二个元素。
我注意到，元素似乎没有
浏览 2提问于2016-05-17得票数 2
回答已采纳
我正在开发一个嵌入式Linux系统(3.12)，我们的应用程序在经过一些随机的时间之后，开始占用CPU。我已经在我们的应用程序上运行了strace，当问题发生时，我在strace输出中看到了许多类似于此的行：
[48530666] futex(0x485f78b8, FUTEX_WAIT_PRIVATE, 2, NULL) = -1 EAGAIN (Resource temporarily unavailable) <0.009002>
我很确定这是我要找的冒烟枪，而且有某种种族。然而，我现在需要弄清楚如何识别代码中试图获取这个互斥体的位置。我怎么能这么做？我们的代码是用GCC编译
浏览 5提问于2015-09-23得票数 1
1回答
多线程for服务器的线程池
、、、、
我想写一个多线程的网络服务器，我应该使用线程池。我可以为线程池使用队列吗?如果可以，您建议队列是循环队列还是双链接列表？哪个更适合我的web服务器实现？如果队列不是一个好的选择，那么建议线程池使用什么数据结构？
浏览 3提问于2013-11-05得票数 1
回答已采纳
3回答
有趣的是，这似乎是一个基本的问题，但我在C语言中找不到它的任何例子(因此，我只找到了Python、C#和C++)。
要点是:作为一个Qt程序员，当我需要在不同线程之间传输一些数据时，我会在此之间启动一个信号槽连接，并使用emit signal机制来完成工作。
但是现在我正在为嵌入式Linux开发一个C应用程序，在那里我需要做类似的工作，但是我没有Qt的机制。问题是：如何使两个或多个线程在C中以类似于Qt具有信号和插槽的方式进行通信？
我知道共享数据的方法之一是使用具有互斥保护变化的全局变量。但是即使这样，我也可能无法以异步的方式完成系统:我必须有一个循环来不断地检查变量是否已经改变。但是，如果
浏览 7提问于2014-09-16得票数 9
4回答
我是多线程编程的新手，我只知道最常见的生产者-消费者-队列。我正在使用boost c++库，我不知道使用boost::lockfree::queue还是使用使用mutex和condition\_variable的std::queue的包装类更好。
使用无锁数据结构更好，使用基于mutex和condition\_variables的简单实现更好
浏览 0提问于2013-04-29得票数 13
回答已采纳
2回答
队列的同步
、、、
在我的程序中，我有一个“发送者”和“接收者”线程，这两个线程都作用于一个队列。
我在类中将我的队列定义为：
static Queue<my_class> queue = new LinkedList<my_class>();
然而，我认为我遇到了问题，因为我的Queues没有同步。在我的"Receiver“线程中，有时我必须从队列中删除项目，这将影响"Sender”线程的操作方式。
我正在读关于BlockingQueues的文章，想知道在我的情况下，这是不是我需要使用的东西？如果是这样，我如何更改我的声明？我是否也需要在“发送者”和“接收者”线程中声明B
浏览 2提问于2013-06-04得票数 0
2回答
我在查看“基于典型生产者-消费者场景的用法示例”，网址是：
这个例子正确吗？
我认为在继续修改队列之前，put和take操作需要锁定一些资源，但这里没有发生这种情况。
此外，如果这是一种并发类型的队列，那么缺少锁是可以理解的，因为并发队列上的原子操作不需要锁。
浏览 1提问于2011-06-30得票数 0
回答已采纳
2回答
如果只有一个线程要添加到队列中，并且只有一个线程要从队列中检索，那么我认为没有必要为这些访问操作锁定队列。
通常情况下，检索将在循环中进行。如果它遗漏了一个项目，它将在下一次尝试中获得它。唯一需要关注的是获取部分数据。如果是值类型队列，并且值大于一个基本内存单元，则可能会发生这种情况。但是如果它是一个引用类型，它应该是可以的。
我说的对吗？
浏览 0提问于2010-08-04得票数 2
回答已采纳
我们在监控程序中遇到了一个问题。
程序的流程是
Customer /sftp文件(以.csv格式)到“源文件”目录
Bash脚本将完成的.csv文件重命名为.aaa文件
另一个Bash脚本将".aaa“文件移动到”目的“目录，并将该文件重命名为".csv”。
骆驼在监视“目的地”目录。如果有任何文件到达“目的”文件夹，并且扩展名不等于".aaa“，则将开始处理该文件。
在这里，第三步失败了。Bash脚本成功地移动文件。但是，当将文件从".aaa“重命名为".csv”时，骆驼将获取文件并开始处理。骆驼失败，错误“页脚不存在”。这是因
浏览 1提问于2009-12-08得票数 0
1回答
改进多线程代码设计以防止争用条件
、、、、
我遇到了一个问题，我不确定它是否能以我想要解决的方式解决。我的种族状况有问题。
我有一个项目运行作为一个C++ dll (主机)。然后，我有了第二个C#进程，它使用C++/CLI与主引擎(编辑器)通信。
编辑器将引擎窗口作为子窗口承载。其结果是子窗口接收输入消息异步(请参阅RiProcessMouseMessage())。通常，只有当我调用window->PollEvents();时才会发生这种情况。
main engine loop {
RiProcessMouseMessage(); // <- Called by the default windows message
浏览 16提问于2020-12-23得票数 1
我在内存数据存储中发现了几个非堆，如Chronicle、mapdb等……它们都使用了锁(标记为读写锁，或重入读写锁)。 在Java上有无堆和锁的数据结构吗？或者是否存在无读锁的离堆数据结构？
浏览 41提问于2020-11-09得票数 2
1回答
编写一个生产者/消费者队列的最有效方法是什么，其中一个线程是生产者，另一个线程是消费者。在一篇论文中，作者说只需要一个原子操作就可以将一个元素插入到他的队列中，但他没有解释是如何做到的。
此外，他的队列是一个循环队列，如果队列为空，则消费者等待，而如果队列已满，则生产者等待。他怎么可能实现这样一个队列。他所说的原子操作，是指某种互斥还是仅仅是一个原子变量。注意，他说，一个原子操作。
浏览 1提问于2012-07-06得票数 1
回答已采纳
1回答
基本上，我的问题是:在没有同步的情况下调用front+pop和从两个线程推送是安全的吗？我读过这篇文章，但一直没有找到明确的答案。人们说你应该使用互斥，但有些人暗示你可以使用两个不同的互斥用于推和流行。是真的吗？
此代码是否有未定义的行为？
std::queue<int> queue;
int pop()
{
int x = queue.front();
queue.pop();
return x;
}
void push(int x)
{
queue.push(x);
}
int main()
{
queue.push(1);
浏览 1提问于2014-12-15得票数 4
回答已采纳
据我理解
block is there are =1 task could progress if there are N tasks concurrent running
and one enter the critical area(enter the critical area one).
lock-free is there are >=1 tasks could progress if there are N tasks concurrent
running and one enter the critical area.
wait-free is there are
浏览 1提问于2013-12-12得票数 0
回答已采纳
2回答
在C中寻找正确的环缓冲区实现
、、、、
我正在寻找C中具有以下特性的环缓冲区实现(或伪代码)：
多生产者单消费模式
空用户块
生产者完全封锁
无锁(我期望高争用)
到目前为止，我只使用SPSC缓冲区--每个生产者一个--但我希望避免使用者不断地旋转，以检查其所有输入缓冲区上的新数据(也许是为了摆脱我系统中的一些封送处理线程)。
我是在Intel机器上为Linux开发的。
浏览 6提问于2012-09-04得票数 8
回答已采纳
3回答
已解决
我将bfs::directory_iterator队列更改为std::string队列，并出人意料地解决了问题。
嗨，我有一种直觉，我做错了事情。
我已经实现(或尝试)了线程池模式。
N个线程从队列中读取数据，但我遇到了一些问题。下面是我得到的信息：
//inside a while loop
bool isEmpty;
bfs::directory_iterator elem;
{
boost::mutex::scoped_lock lock(this->queue_mutex);
isEmpty = this->input_queue.isEm
浏览 4提问于2009-09-23得票数 2
回答已采纳
4回答
我正在寻找一个单生产者、单消费者的FIFO实现，它的执行速度要比普通的lock-write-unlock-signal / waitForSignal-lock-read-unlock快。我正在寻找用C或C++编写的大多数POSIX操作系统(特定于x86的)都支持的东西。
我不想传递任何比指针更大的东西。
我不一定喜欢无锁的想法，但我确实想要一些快速和正确的东西。我读过的一篇关于这个主题的论文提到了一种似乎很有趣的双队列方法，但从那时起，我就再也找不到关于它的信息了。
从我到目前为止所做的研究来看，0mq (它的inproc://方案应该使用无锁结构)看起来是最有吸引力的选择。这就是说，在我走
浏览 2提问于2011-07-10得票数 5
回答已采纳
6回答
我使用的是主动对象设计模式。
我需要一个列表，其中包含相同类型的用户定义的对象。多个写入器将对象推送到列表，读取器可以定时地等待队列。
我知道我可以包装一个STL列表，但也许boost中有现成的解决方案？我就是找不到。
更新：
该应用程序在Linux (RHEL 5.3)上运行。
浏览 6提问于2009-12-11得票数 2
我正在尝试实现单个生产者(主线程)和单个使用者(从Main派生的子线程)问题，因此根据我的搜索，我得到了spsc_queue作为boost库提供的最好的无锁数据结构。从它们的示例代码中可以看出，使用者函数如下所示：
void consumer(void)
{
int value;
while (!done) {
while (queue.pop(value))
++consumer_count;
}
while (queue.pop(value))
++consumer_count;
}
现在，可能发生的
浏览 1提问于2015-09-14得票数 0
回答已采纳
1回答
在Linux中，假设我有100个线程的代码。这些线程中有5个竞争由互斥锁保护的共享资源。我知道当临界区实际运行时，如果5个线程试图获得锁，则只有5个线程会停止执行，而其他95个线程将正常运行。
我的问题是，是否存在其他95个线程的执行将暂停或受影响的时间点，即互斥量/内核/什么决定哪些线程在互斥量上被阻塞，哪个线程应该获得锁，以及哪些线程应该能够运行，因为它们没有请求锁，等等
浏览 5提问于2013-03-29得票数 1
回答已采纳
1回答
我正在开发一个游戏服务器。通过TCPListener，我接受客户端。
var Listener = new TcpListener(IPAddress.Any, CommonConfig.Settings.GamePort);
Listener.Start();
ListenerStarted = true;
while (ListenerStarted)
{
TcpClient tcpClient = await Listener.AcceptTcpClientAsync();
ProcessClientTearOff(tcpClient);
}
然后通过ReadAsync从
浏览 2提问于2018-05-25得票数 1
1回答
可变长度的无锁队列？
、、、
我在C/C++中搜索了相当多的无锁队列，但是它们中的大多数必须指定最大数量的元素，包括boost::lockfree。
有人能给我一些关于可变长度、多个生产者和多个消费者无锁队列的信息吗？
浏览 2提问于2013-08-27得票数 1
我正在Linux中用c/c++开发一些程序。我的问题是：
我有一个名为Vault的高级类，其中有一个使用OrderMap作为数据结构的unordered_map，还有一个OrderBook，它的旁边有2个std::list。
OrderMap和OrderBook都存储Order*作为元素，它们共享堆上分配的Order对象。因此，OrderBook或OrderMap都会修改内部的顺序。
我有两个线程对它们执行读写操作。这两个线程可以插入/修改/检索(/delete)元素。
我的问题是:我怎样才能保护这个“地下室”的大结构？我实际上可以保护地图或列表，但我不知道如何同时保护它们
浏览 7提问于2015-06-09得票数 0
7回答
我见过一些堆栈的无锁实现..。我的问题是可见性，而不是原子性。例如，无锁堆栈的元素(，不是指针，)最多必须是64位吗？我想是的，因为你不能保证能见度。实际例子:这个结构能被安全地插入并从无锁容器中删除吗？
struct person
{
string name;
uint32_t age;
}
编辑:有些人被这个问题弄糊涂了。解释一点:如果作者推送人，读者就会得到它，是否保证读者看到(记忆可见性)正确的人的内容。
浏览 2提问于2011-09-28得票数 10
1回答
我正在编写一个并发的TCP服务器，它必须处理与‘每个连接’方法的多个连接(使用线程池)。我怀疑哪个是每个线程获取不同文件描述符的最佳方式。
我发现接下来的两种方法是最推荐的：
一个主线程，它将所有传入的连接和存储在数据结构上的上(例如：queue)。然后，每个线程都能够从队列中获得一个fd。
是从每个线程直接调用的。( 推荐)
我对他们每一个人都发现了以下问题：
存储所有fd的静态数据结构必须是locked (mutex_lock)，然后线程才能从中读取，因此在相当多的线程想要在中读取完全相同的时刻()的情况下，我不知道在所有线程都实现目标之前需要多少时间。
我一直在
浏览 5提问于2013-07-13得票数 11
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
