标签: concurrent-programming

我意识到当我尝试使用多个线程处理并发队列中的项目而多个线程可以将项目放入其中时,理想的解决方案是将Reactive Extensions与Concurrent数据结构一起使用.

我原来的问题是:

使用ConcurrentQueue时,尝试在并行循环时出列

所以我很好奇是否有任何方法可以让LINQ(或PLINQ)查询在项目被放入其中时不断出列.

我试图让这个工作的方式,我可以有n个生产者进入队列和有限数量的线程进行处理,所以我不会重载数据库.

如果我可以使用Rx框架,那么我希望我可以启动它,如果在100ms内放置了100个项目,那么作为PLINQ查询一部分的20个线程将只处理整个队列.

我正在努力合作的技术有三种:

1. Rx框架(Reactive LINQ)
2. PLING
3. System.Collections.Concurrent结构

在阅读并发编程时,我在比较和交换以及比较和设置操作中遇到了共识数这个术语.我无法理解这个术语的含义,任何人都可以解释一下吗？

谢谢!!

在查看一些与此问题无关的错误的数据库代码时,我注意到在某些地方List<T>使用不当.特别:

1. 有许多线程同时访问List作为读者,但使用索引到list的,而不是enumerators.
2. 有一位作家list.
3. 没有同步,读者和编写者同时访问list,但由于代码结构,在执行返回的方法之前永远不会访问最后一个元素Add().
4. 没有任何元素被删除list.

通过C#文档,这不应该是线程安全的.但它从未失败过.我想知道,因为具体实施的,List(我在内部假定它是一个数组是重新allocs当它运行的空间),它的1-作家0枚举正阅读器插件唯一的方案偶然线程安全的,或者是否有一些不太可能的情况,这可能会在当前的.NET4实现中爆炸？

编辑:重要细节我遗漏了阅读一些回复.读者将List其内容视为只读.

我在这里想:如果你有2个线程执行需要同步的FAST操作,那么阻塞/上下文切换方法不是更快/更好的非阻塞方法吗？

通过非阻塞我的意思是:

while(true){if(checkAndGetTheLock())break; }

我唯一能想到的是饥饿(CPU烧坏),如果你有太多的线程在锁定周围循环.

如何平衡一种方法与另一种方法？

只是在我的业余时间玩弄并发,并希望尝试防止撕裂读取而不使用读取器端的锁定,因此并发读取器不会相互干扰.

想法是通过锁序列化写入,但在读取端只使用内存屏障.这是一个可重用的抽象,它封装了我提出的方法:

public struct Sync<T>
    where T : struct
{
    object write;
    T value;
    int version; // incremented with each write

    public static Sync<T> Create()
    {
        return new Sync<T> { write = new object() };
    }

    public T Read()
    {
        // if version after read == version before read, no concurrent write
        T x;
        int old;
        do
        {
            // loop until version number is even = no write in progress
            do
            {
                old = version;
                if (0 == (old & …

Google App Engine提供诸如任务队列和后端(现在的模块)之类的服务,以并行处理请求和执行"并发工作".使用Pipelines API,Fantasm等可以轻松实现典型的扇入扇出/分叉连接技术.

在配置后端/模块的硬件时,可以在B1,B2,B4,B8之间进行选择,但是它没有说明CPU配置中的内核数量.也许CPU核心数量与此无关.后端支持为每个传入请求生成"后台线程",但由于着名的GIL(全局解释器锁),Python实际上无法进行真正的并发工作.

在启动新实例之前,一个前端实例将处理8个请求(默认值,最多30个).

带有Threadsafe指令的Python 2.7据说可以在一个隔离的实例上并行处理传入的请求,这是正确的,还是仅传入跨真实并发的独立实例的传入请求？

在Google App Engine上,实际使用真正的并发技术实现了什么,另一方面,推荐的设计模式是什么获得了最真实的并发和扩展？

您可以使用10-20个驻留B8实例进行"手动扩展"后端/模块,每个实例产生10个"超出生产"的后台线程,并为I/O工作始终执行10个并发异步URL提取,或者是否应该扇动-out与动态实例创建？

作为一名经常靠近硬件工作的电气工程师(编写C),我一直对从任何给定的计算机体系结构中提取最大性能感兴趣.我一直对竞争架构性能分析感兴趣.

我有兴趣猜测是否有必要进行轻度到中度的更改,例如分支预测实现或CPU上的高速缓存大小,这些可能在像Rust这样的并发运行时比在C等过程运行时更高效.分支预测是在分析程序代码的研究论文中得出的概括上实现的.我想知道并发抽象是否会为运行时添加一个重要的工作集,从而对现有的预测算法产生负面影响.例如,在for循环中进行预测是一回事,但是当分支的目标始终是内存的一些新部分(图形,文本等)时,它将始终是缓存未命中,并且永远不会有分支它的历史 - 因为它们都没有碰过它.

这可能是一个愚蠢的问题,因为内容虽然可能总是在RAM中,但会分支到比它使用的数量级更少(一旦它被加载到缓存中)......但仍然存在应该是存储在过程运行时的高速缓存和分支预测变量中的上下文的可观察时间边界,它将在更加并行化的环境中表现为抽象边界.

-

所以我想知道......

是否遵守了这些界限？

哪些研究论文对此进行了分析？

CPU架构是否足够通用,以至于高度并发的语言不会遇到现代CPU架构中可能存在的固有程序偏差？

ConcurrencyLevel 是否有一些最佳值，超出 ConcurrentHashMap 的性能开始下降？

如果是，该值是多少，性能下降的原因是什么？（这个问题源于试图找出 ConcurrentHashMap 可能具有的任何实际限制）。

我有一个具有以下配置的 Windows 桌面：Intel Xeon(R) CPU E5645 @2.40GHz（2 个处理器），
具有 24 GB RAM 和 64 位操作系统

当我运行以下代码时。

var cpuCount = require('os').cpus().length;

它返回 cpuCount 为 24

有人可以解释一下这到底是什么意思吗？它如何确定我有 24 个 CPU 而只有 2 个处理器。

我正在为多组可迭代对象运行一个函数，在所有进程完成后立即返回所有结果的列表。

def fct(variable1, variable2):

   # do an operation that does not necessarily take the same amount of
   # time for different input variables and yields result1 and result2

   return result1, result2

variables1 = [1,2,3,4]
variables2 = [7,8,9,0]

with ThreadPoolExecutor(max_workers = 8) as executor:
    future = executor.map(fct,variables1,variables2)
    print '[%s]' % ', '.join(map(str, future))

>>> [ (12,3) , (13,4) , (14,5) , (15,6) ]

如何在计算结果后立即打印中间结果，例如变量 1 = 1、变量 2 = 7？