在过去的几年中，通过OpenCL和CUDA等系统向数据并行编程的方向发生了重大转变，但即使在过去六个月内出版的书籍也从未提及数据并行编程的主题 它并不适用于所有问题，但似乎这里有一个明显的差距没有得到解决；有一些资源（）包括数据并行性主题。首先，我要指出并发编程不一定就是并行编程的同义词。并发编程是从松散耦合的任务构造应用程序。例如，对话框窗口可以与作为单独任务实现的每个控件进行交互。另一方面，并行编程明确地将某些计算任务的解决方案分散到多个执行硬件上，基本上总是出于某种性能原因（注意：当替代方

我在多GPU系统上运行cuda内核函数，使用4GPU。我希望它们能同时发布，但事实并非如此。我测量每个内核的启动时间，第二个内核在第一个内核完成执行后启动。因此，在4GPU上启动内核并不比1单个GPU快 如何使它们同时工作 这是我的代码： cudaSetDevice(0); GPU_kernel<<< gridDim, threadsPerBlock >>>(d_result_0, parameterA +(0*rateA), parameterB + (0*

我正试图制作一个Erlang程序，用进程查找素数（我知道这是无效的，但嘿，这只是为了好玩：）-类似于 在每一个“勾号”上，服务器都会产生一个新的进程（“编号”），该进程会增加其计数器。若counter==那个数字，那个么它是一个因子，所以我们会让服务器知道。若服务器并没有收到任何消息，那个么它就是一个素数 对于较小的数字（素数高达N，服务器（50，L）行），这是可以的，但对于较大的数字，它会崩溃： 使用退出值处理时出错：{badarg，[{primes，number，2，[{file，“prim

我有一个两层的web服务——只有我的应用服务器和一个RDBMS。我想移动到负载平衡器后面相同的应用程序服务器池。我目前正在缓存一堆正在处理的对象。我希望将它们移动到共享的Redis 我有十几个简单的小型业务对象的缓存。例如，我有一组Foos。每个Foo都有一个唯一的FooId和一个所有者ID。 一个“所有者”可能拥有多个foo 在传统的RDBMS中，这只是一个表，其索引位于PK FooId上，索引位于OwnerId上。我将其缓存在一个进程中，只是： Dictionary<int,Foo&g

我的教科书《计算机系统：程序员的视角》给出了以下线程不安全函数的示例： unsigned int next = 1; int rand () { next = next * W + X; return (unsigned int)(next/Y) % Z; } void srand (unsigned int seed) { next = seed; } 书中说，修复此函数的唯一方法是重写它，使其可重入。我很难理解为什么不能使用互斥锁将写入同步到下一个。我可以理解为

TL；DR 我有生产者、任务和消费者。我需要一个可扩展的排队系统，它可以确保一个任务可以被使用一次，而且只能使用一次，并且可以根据任务的优先级对任务进行排序 上下文： 我们有一个原型正在工作，但它还没有“准备好缩放”，今天我们需要缩放 以下是原型“流程”： 1°）部分客户在数据库中上传数据集（PostgreSQL） 每秒，应用程序获取数据库中的新数据集并将其转换为任务。 一个客户的数据集可以生成数千个任务（~500K个任务/天，~30K个任务/客户） 3°）应用程序“调度器” 从数据库中获取已

我想确保只有1个线程可以访问我的服务函数中的实体。怎么做 示例：我希望安全地减少计数：即使多个线程执行OrderService.remove（产品），我也不希望使用相同的计数器值进行2次DB更新 在多线程环境中，2个线程可以同时执行此函数，它们可以读取相同的计数器值，因此使用相同的减少值更新数据库。这是不可取的 产品： @Entity public class Product { @Id @GeneratedValue private UUID id; pri

我需要为支持并发的解释器编写一个垃圾收集器，但是我只能找到关于垃圾收集的信息，而与并发无关 在多线程系统中是否有特定的对象垃圾收集方法？我在哪里可以找到有关其架构和实现的信息？也许我只是不太了解这一点。。。但并发性与一个对象有多少引用是活动的有什么关系呢？它要么有活的参考，要么没有；多个线程对此没有影响 我可以看到，可能必须分别跟踪每个线程，以查看哪些引用是活动的或不活动的。但这应该只是多次应用单线程跟踪 另外，为什么不在已经完成所有这些工作的虚拟机上编写解释器呢？就像JRuby（JavaVM）

如果可以向多个客户机提供服务，如果提供此服务的服务器出现故障，另一个将取代它，而不需要某种集中的“控制”，检测主服务器是否出现故障，并将客户机重定向到新服务器 是否可以不使用集中接口/网关 换句话说，这有点像是在问：你能设计一个节点平衡器，而不需要对直接客户端进行集中控制吗？好吧，你没有提供太多关于你所问的“服务”的信息，所以我将以一般方式回答 对于我回答的第一部分，我假设您正在谈论涉及ip地址的“集中式接口/网关”。为此，有CARP（公共地址冗余协议），引自： 公共地址冗余协议（CARP）是一

在我开始做网络编程之前，我认为这很容易。现在，经过一年的经验，我认为这真的很难，主要是因为并发问题 因为这是一个非常意外的发现，我试着问我更有经验的朋友（他们制作了一些像电子商店等的应用程序）。具体地说，我问他们你是否真的有需要解决的并发问题，或者你的数据有变得不一致的危险，他们说：“嗯，从来没有想过。”。这让我有点担心自己的理智，甚至连一些令人筋疲力尽的网络搜索都不能令人信服地回答这个问题 因此，在这里，我要确保我的思想轨道不会导致一个非常白色的蜂窝状房间： 1） 假设LAMP框架，apach

这个问题与使用cuda流运行许多内核有关 在CUDA中有许多同步命令 cudaStreamSynchronize， CudaDeviceSynchronize， cudaThreadSynchronize， 还可以使用cudaStreamQuery检查流是否为空 我注意到在使用探查器时，这些同步命令会给程序带来很大的延迟。我想知道除了使用尽可能少的同步命令之外，是否有人知道减少延迟的方法 是否有数据可以判断最有效的同步方法。考虑到应用程序中使用的3个流，其中两个需要完成我的第四个流，如果我使用2

我想知道hbase-0.90.0是否存在与多个客户端同时写入同一行相关的已知问题。在我的设置中，有超过10个节点写入同一个HBase表，有时（非常罕见）我看到数据没有写入表，我记录异常等，但我没有看到。一种可能是多个节点同时写入同一行，我想知道这是否会导致这种行为。谢谢 您正在使用的Hadoop版本-某些旧版本没有持久同步，可能会丢失数据： HBase将丢失数据，除非它运行在具有 持久同步实现。Hadoop 0.20.2、Hadoop 0.20.203.0和 Hadoop 0.20.204.0没

我有一个测试程序，当在多个Cpu上执行多个goroutine（Goroutines=Cpu）时，它会给出不同的结果。“测试”是关于使用通道同步goroutines，程序本身统计字符串中字符的出现次数。它在一个Cpu/一个goroutine上产生一致的结果 请参阅游乐场上的代码示例（注意：在本地计算机上运行以在多核上执行，并观察结果数字的变化）： 代码摘要：程序统计（DNA）字符串中4个不同字符（A、T、G、C）的出现次数 问题：在多个Cpu（goroutines）上执行时，结果（n个字符的出现）

如何通过编程方式在设备/nvidia图形卡上找到并发cuda线程或流式多处理器的最大数量？我知道warpSize，但没有warpCount 关注从PDF中查找内容。您是否尝试过检查他们的SDK示例，我认为此示例正是您想要的 您是否尝试过检查他们的SDK示例，我认为此示例就是您想要的示例 您是否尝试过检查他们的SDK示例，我认为此示例就是您想要的示例 您是否尝试过检查他们的SDK示例，我认为此示例就是您想要的示例 这不仅取决于设备，还取决于您的代码-例如，每个线程使用的寄存器数量或块需要的共享内存

我最近学习了F#异步工作流，这是F#并发的一个重要特性。让我困惑的是，有多少种方法可以在F#中编写并发代码？除了F#之外，我还读过一些关于F#并发性的博客，我知道一些事情，比如背景工作者；IAsyncResult；如果在本地机器上编程，则F#中存在碎片内存并发；如果在分布式系统上编程，则存在消息传递并发性。但我真的不确定这些技术之间的关系是什么，以及如何对它们进行分类。我知道这是一个相当“大”的问题，不能用一两句话来回答，所以如果有人能给我具体的答案或推荐一些有用的参考资料，我将不胜感激。我对F

我正在努力了解戈罗季斯。以这个代码为例： package main import "fmt" var ( b1 []float64 b2 []float64 ) func main() { go fill(&b1, 10) go fill(&b2, 10) fmt.Println(b1,b2) var s string fmt.Scanln(&s) } func fill(a *[]float64, n i

来自clojure的勇敢与真诚： (defmacro enqueue [q concurrent-promise-name & work] (let [concurrent (butlast work) serialized (last work)] `(let [~concurrent-promise-name (promise)] (future (deliver ~concurrent-promise-name (do ~@concur

我曾几次纠结于一些代码，这些代码似乎是完全正常的verilog风格，但对我来说相当危险（我是verilog新手）。它总是关于并发块和/或分配。以下是一个例子： module some(input clk_i); .. module ram( input wire a_clk, input wire a_wr, input wire [ADDR-1:0

我正在为后端使用AppSync构建一个Angular 11 web应用程序 我提到了群聊，但基本上我的应用程序中有一个功能，我有一个公告功能，其中有一个人向特定受众（可以是个人成员或成员组）创建公告，每当接收用户打开公告，它必须在用户界面中将该公告标记为该用户已读，并让发件人知道该特定成员已打开该公告 我有一个实现这一点的想法：- 每个公告都需要有一个“seenBy”，它聚集了打开它的人的用户ID 每个成员的用户对象中都有一个名为“announcementsRead”的属性，该属性是他们打开的公

在Maurice Herlihy的论文“无等待同步”中，他定义了无等待： “并发数据对象的无等待实现可以保证 任何进程都可以在有限的步骤内完成任何操作，无论 其他进程的执行速度。” 让我们从宇宙中进行一次行动 （1） 这个定义是否意味着：“每个进程在相同的有限n个步骤中完成一个特定的操作op。” （2） 或者它的意思是：“每个进程在任何有限的步骤中完成一个特定的操作op。因此一个进程可以在k个步骤中完成op，而另一个进程可以在j个步骤中完成op，其中k！=j.” 只要读一下定义，我就能理解（2

我有两个并发的go例程，如下所示 Routine 1{ routine procedure critical section{ } routine procedure } Routine 2{

我试图实现一个基于数据结构（眨眼树）和算法的数据库索引，该算法由Lehman和Yao在年提出。在第2页中，作者声明： 磁盘按固定大小分区（物理页；在本文中，这些页对应于树的节点）这些是进程可以读取或写入的唯一单元。[emphasis mine]（…） （…）允许进程锁定和解锁磁盘页。此锁授予该进程对该页面的独占修改权限；另外，一个进程必须锁定一个页面才能修改该页面。（…）锁定不会阻止其他进程读取锁定的页面。[emphasis mine] 我不完全确定我的解释是否正确（我不习惯阅读学术论文），但我

假设您的系统中有一个实体，比如说，Person，您希望处理修改各种Person实体的事件。重要的是： 同一个人的事件按FIFO顺序处理 多人事件流可以由不同的线程/进程并行处理 我们有一个使用共享数据库和锁解决这个问题的实现。线程竞争为一个人获取锁，然后在获取锁后按顺序处理事件。我们希望转移到消息队列以避免轮询和锁定，我们认为这将减少数据库上的负载并简化消费代码的实现 我已经对ActiveMQ、RabbitMQ和HornetQ做了一些研究，但是我没有看到一个明显的实现方法 ActiveMQ支持使

我有一些问题。。。在缓冲信道上 问题1 那么为什么非缓冲区从不输出真值呢 这是否意味着无缓冲通道始终关闭？ 那么，为什么无缓冲通道仍然能产生正确的斐波那契计算结果呢 问题2 为什么非缓冲输出在中间被切断，如下所示？ 0 1 1 2 NB value: 0 NB ok: false 3 这应该与goroutine有关，但为什么会这样呢 这是很难理解的，因为如果我缓冲这个通道，我会得到真值，但对于非缓冲通道，我只会得到假值 请查看以下链接 主程序包 输入“fmt” f

目前，我开发了一个基于GPU的程序，它使用多个内核，通过使用多个流同时启动 在我的应用程序中，多个内核需要访问队列/堆栈 我计划使用原子操作 但我不知道原子操作是否在同时启动的多个内核之间工作。 请帮助我任何知道GPU上原子操作的确切机制的人 原子是在GPU的二级缓存硬件中实现的，所有内存操作都必须通过该硬件。没有硬件来确保主机和设备内存之间或不同GPU之间的一致性；但是，只要内核运行在同一个GPU上，并使用该GPU上的设备内存进行同步，atomics就会按预期工作。您尝试过什么吗？这根本不是我

使用F#中的MailboxProcessor，他们之间的首选通信方式是什么将代理包装到以下对象中： type ProcessAgent(saveAgent:SaveAgent) = ... type SaveAgent() = ... let saveAgent = new SaveAgent() let processAgent = new ProcessAgent(mySaveAgent) 或者说： type ProcessAgent(cont:string -> unit) =

在开普勒3.5GPU的同一个流式多处理器上，使用流是否可能有多个唯一的内核？也就是说，在具有15条SMs的开普勒GPU上，在compute capability 3.5设备上同时运行30个大小的内核是可能的 这些设备支持每个GPU最多32个并发内核和2048个对等多处理器线程。对于每个多处理器64k寄存器，如果每个线程的寄存器占用空间小于16个，并且每个块的共享内存小于24kb，则1024个线程的两个块可以并发运行 您可以在CUDA编程指南的附录中找到所有这些硬件描述。在compute capa

我有一个队列，我想执行以下操作： 弹出第一个元素 如果元件为偶数，则推动元件+1 这应该一直持续到队列为空；此外，我想同时使用多个goroutine 我可以为一个goroutine做些什么，但只要我添加一段时间，一切都会出错，因为似乎创建了太多goroutine。即使放置else{return}也不能解决问题。附带问题：为什么不呢？我得到了错误： syntax error: unexpected semicolon or newline before else syntax error: u

我正在用erlang编写一个服务器，它处理大量的消息（记录）。 每个消息都有一个类似于用户id的标记（atom） “路由器”将为该用户生成一个专用的永久进程（在保存和传递消息之前积累几分钟），如果该进程不存在的话。否则，它会将其作为消息传递到现有进程邮箱 问题是路由表的簿记 我可以考虑序列化路由器，每条消息都会导致ETS查找，根据用户ID查找PID，如果没有退出，则最终生成并插入ETS。但几秒钟后就堵塞了 另一种方法是直接生成一个进程来路由每条消息，但如果发送给单个用户的几条消息连续出现，并且在

我正在阅读futurespreview0.3版资料，了解如何正确地“通知任何人”。在mpsc:：channel（有界）中，多个发送方可以等待接收（在缓冲区已满的情况下） 查看and的实现情况，接收方似乎只会在每次接收时通知一个发送方 我怀疑这在目前的情况下是否有效，因为select可能导致错误通知。然而，我无法提出一个问题案例 下面是我试图混淆的mpsc： [软件包] name=“期货mpsc测试” version=“0.1.0” edition=“2018” [依赖关系] 期货预览={vers

我是一名学生，目前正在撰写关于Raku的论文，为此我决定评估Raku（Perl 6）在处理高并发性时是否是一种好语言 除了官方网站外，我还没有找到任何关于Raku并发性的文章。此外，我不知道如何评估Raku的并发性（例如，我应该使用什么程序，应该将哪种语言与Raku进行比较，等等） Raku提供了哪些并发机制？这些文件记录在哪里？如何评估它们的功能和性能？关于Raku并发性的论文：如果你想了解并发性是如何工作的，我知道没有学术论文。例如，您可以在某些降临节日历出版物中查找。大多数关于Raku的书

我正在从事一个项目，该项目模拟多个处理器处理命令和排队字符串，以便通过一个后台处理程序打印 最多有十个处理器，每个处理器执行一系列包含“compute”和“print”语句的作业。计算只是一个数学过程，需要花费时间来模拟其他工作，而print将短字符串传输到后台打印程序进行打印。有一个后台处理程序，一台打印机连接到后台处理程序。每个处理器将在终止前处理多个作业，特定处理器上特定作业的所有打印语句应一起打印（单个作业的打印不交叉），并且后台打印程序在正在计算的进程上不应被阻止 我通常理解如何使用信

如果我有一个非常简单的服务，它是在一台服务器上完成的，那么我如何使这个服务具有可伸缩性，比如在多台服务器上运行？它是否使用寄存器（mod，func，[args]） 我对生成进程、创建节点和创建新服务器感到有点困惑 如何将客户端活动卸载到新的服务器上以分散负载？生成过程可以让您实现更大的粒度，从而有效地利用多核。它还为您提供了实现异步行为的机会 通过创建节点，可以将系统分布到多个主机上。节点可以看到彼此并透明地通信 若服务器是无状态的，那个么只需创建两个服务器节点，并在它们之间实现负载平衡 若服务

我正在进行golang之旅，并正在进行最后一个练习，将网络爬虫更改为并行爬网，而不是重复爬网（）。我所改变的只是爬网功能 var used = make(map[string]bool) func Crawl(url string, depth int, fetcher Fetcher) { if depth <= 0 { return } body, urls, err := fetcher.Fet

我在玩围棋，我有一个无法解决的问题 下面的代码是最不可能重现我的问题的代码。目标 原始代码的一部分是将http请求委托给goroutines。每一次狂欢 做了一点繁重的图像计算，应该会有反应 package main import ( "fmt" "runtime" "net/http" ) func main() { http.HandleFunc("/", handle) http.ListenAndServe(":8080", nil) } f

我正在实现循环缓冲区，如下所示： long windex = 0, rindex = 0, count = 0; producer_ISR() /* whenever the data avail, then gets the interrupt */ { /* store the data in array buffer */ array[windex] = data; windex++; count = count + 1; /* Increment t

我总的来说在考虑信号分配，我陷入了进退两难的境地 如果我有一些项目，其中我有以下代码： ARCHITECTURE wait_example of wait_example IS SIGNAL sendB, sendA : std_logic; BEGIN sendA <= ‘0’; A : PROCESS BEGIN -- something END PROCESS A; B : PROCESS BEGIN -- something END PROCESS B; C : PROCE

我试图在开普勒设备上重叠内核执行，但从NVVP布局来看，它们似乎没有重叠。这是密码 #include<stdio.h> #include<sys/time.h> #include<time.h> #define NY 1024 #define NX 1024 __global__ void kernel1(int j,int *A,int *b) { int i = blockIdx.x * blockDim.x + threadIdx.x;

“如果你能感觉到一台计算机的操作每几毫秒就切换一次几十项任务，那么你肯定会同意，即使我们知道计算机正在交错执行各种任务的计算，计算机似乎同时执行这些任务。” M.Ben-Ari，《并发编程原理》，1982年 因此，在单核CPU上，单个原子操作不可能与同一系统中的另一个原子操作同时执行？是的，单核CPU可以同时执行多个操作。例如，奔腾处理器有多个并行运行的管道。一个可能正在进行添加，而另一个可能正在进行内存加载。当然，你无法观察同时进行的手术的效果 此外，像奔腾4这样的体系结构是单核的，但也可

有人能给公平和死锁这两个术语下个恰当的定义吗。我被告知这些术语用于并发进程。简而言之，并发进程共享CPU，操作系统为每个进程安排CPU突发运行。公平是实现进步和防止饥饿需要考虑的因素之一 死锁是一种存在依赖循环的情况，其中每个进程等待另一个进程进行。您还需要阅读有关互斥和关键部分的内容。您最好在维基百科上阅读，加1表示“简而言之”

假设以下情况： 有一个盒子，用来存放硬币 人们从盒子里取钱 人们把钱放进盒子里 我把任务分为加、减、读和写。下面是我的代码。现在我不知道如何调用条目加、减和读来达到上述要求，请帮助 with Ada.Text_IO,ada.integer_text_io; use ada.text_io,ada.integer_text_io; procedure protected_imp is task type box(initial_value:integer;min_v

在我的代码中存储配置的一种常见模式是由RWMutex保护的“map[string]interface{}”，但通常在启动应用程序（可以在多个go例程中触发）后，map变成完全只读。所以我有一种感觉，从某个时间点开始，读取时的RWMutex应该是不必要的 此配置映射的示例位于 让我想到这一点的一个事实是，在一些生产代码中，它实际上是以不受保护的方式访问共享对象（虽然它在初始化后大部分是只读的），我理解使用RWMutex进行保护的正常方式，但有趣的是，这种格式错误的代码在过去几个月里没有遇到问题

我试图在Rust async await（很快就会稳定下来）中同时（而不是按顺序）运行一个期货列表，直到其中任何一个解析为true 想象一下，拥有一个Vec，并且将来为每个文件运行一个bool（可能是无序的）。下面是一个简单的顺序实现 async fn my_函数（文件：Vec）->bool{ //在每个文件上运行future，如果收到true，请提前返回 对于文件中的文件{ 如果未来很长（文件）。等待{ 返回true； } } 假的 } 异步fn long_future（文件：file）->b

如何在erlang或elixir中组织对来自一系列进程的数据（例如ETS表）的并行访问？ 在传统模型中，我将创建RWLock，并使临界截面尽可能小。所以，我至少可以通过并行读取访问哈希表。 在erlang中，第一个想法是实现以状态存储表的gen_服务器。但所有访问都将被序列化。如何处理它以更快地提供服务？在调用中使用直接访问并指定read\u concurrency:true GenServer在这里是一个冗余链接，这可能会成为瓶颈。但是在没有类似GenServer的东西的情况下，ets表本身存

我试图理解读取操作在HashTable、HashMap和ConcurrentHashMap内部是如何工作的。 ConcurrentHashMap在内部划分为大小为32的段。因此，一次最多可以读取32个线程。当我们在ConcurrentHashMap中同时对同一段执行两个读取操作时会发生什么 另外，我想知道HashTable HashMap中同一元素上的多个read是如何工作的 ConcurrentHashMap在内部划分为大小为32的段。因此，一次最多可以读取32个线程 这是不对的。根据“检索操

我们正在我们的一个项目中使用消息传递来实现悲观并发。这意味着，如果消息传递停止（通道停止），并发性将停止 这在其他业务应用程序中是否完成 如果消息传递中断，是否关闭应用程序（注销用户） 我更倾向于将乐观和悲观的并发性结合起来。然后，如果悲观并发性下降，仍然存在备份乐观并发性 像往常一样，我认为答案取决于您正在构建的业务应用程序的性质。您的应用程序的SLA是什么？它有多关键 如果您的消息传递基础结构出现故障，应用程序是否会在锁定服务之外继续运行？如果是这样，那么您可能有义务确保并发控制机制不是

我想使用WorkManager在WebLogic 10.3应用程序服务器上安排一些并行作业 我发现Oracle/BEA文档有点零碎，很难理解，而且它没有使用EJB3.0中WorkManager的好例子 具体来说，我想知道： 1） 我到底需要在部署描述符（ejb-jar.xml和friends）中放些什么 2） 我想使用@Resource注释将WorkManager注入EJB3会话bean。我对资源使用什么“名称” 3） 如何为WorkManager配置线程数和其他参数 我的理解是WebLogi

假设我正在使用erl中的一些简单流程： 1> Fun = fun(F) -> F(F) end. #Fun<erl_eval.6.82930912> 2> Pid = spawn(fun() -> Fun(Fun) end). <0.178.0> 3> f(Pid). 1>Fun=Fun（F）->F（F）end。 #乐趣 2> Pid=spawn（fun（）->fun（fun）end）。 3> f（Pid）。 执行f（Pid）时会发生什么

在Erlang中，在处理进程时，必须导出spawn函数中使用的函数 -module(echo). -export([start/0, loop/0]). start() -> spawn(echo, loop, []). “编程Erlang，第二版，第188页”一书中的原因是 “请注意，我们还必须从模块中导出spawn参数。这是一个很好的做法，因为我们可以在不更改客户端代码的情况下更改服务器的内部详细信息。” 在《Erlang编程》一书第121页： -module(frequenc

我试图生成一个在我的映射（atom）中不存在的新密钥，然后立即将其添加到我的映射并返回密钥。但是，对密钥的检查和更新并不是自动完成的。我想知道如何以原子的方式实现这一点，从而确保并发的安全性 理想情况下，此密钥足够短，可以键入，但很难猜测（因此用户可以创建会话，他/她的朋友可以使用该密钥加入）。所以0,1,2,3。。。不理想，因为用户可以尝试进入会话n-1。像UUID这样不用担心碰撞的东西也不理想。我本来打算生成一个短随机字符串（例如“udibwi”），但我在下面的代码片段中使用了rand in