标签: concurrent-collections

是否有一个C#类提供弱键或/和弱值的映射？或至少WeakHashMap之类的功能.

什么是正确的使用,BlockingCollection或者ConcurrentQueue你可以自由地出列项目,而不会使用一个线程烧掉一半或更多的CPU？

我使用2个线程运行一些测试,除非我有一个至少50~100ms的Thread.Sleep,它总是至少达到我CPU的50%.

这是一个虚构的例子:

private void _DequeueItem()
{
    object o = null;
    while(socket.Connected)
    {
        while (!listOfQueueItems.IsEmpty)
        {
            if (listOfQueueItems.TryDequeue(out o))
            {
                // use the data
            }
        }
    }
}

通过上面的例子,我将不得不设置一个thread.sleep,以便cpu不会爆炸.

注意:我也尝试了没有用于IsEmpty检查的时间,结果是一样的.

我正在尝试编写一个程序,我通过将它们放入不同线程的集合中来安排要删除的项目,并在一个迭代集合的单个线程中清理它们并处理这些项目.

在这样做之前,我想知道什么会产生最佳性能,所以我尝试了ConcurrentBag,ConcurrentStack和ConcurrentQueue,并测量了添加10000000个项目所需的时间.

我使用以下程序来测试这个:

class Program
{
    static List<int> list = new List<int>();
    static ConcurrentBag<int> bag = new ConcurrentBag<int>();
    static ConcurrentStack<int> stack = new ConcurrentStack<int>();
    static ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
    static void Main(string[] args)
    {
        run(addList);
        run(addBag);
        run(addStack);
        run(addQueue);
        Console.ReadLine();
    }

    private static void addList(int obj) { lock (list) { list.Add(obj); } }

    private static void addStack(int obj) { stack.Push(obj); }

    private static void addQueue(int obj) { queue.Enqueue(obj); }

    private static void addBag(int obj) { bag.Add(obj); }



    private static void …

我基本上是在寻找从线程中的相机获取的图像集合的容器.由于ConcurrentQueue是线程安全的,我想使用它.但在调试我的代码时,我发现这篇文章说

如果元素很小,你可能永远不会注意到这一点.但是,如果元素保留了大量资源(例如,每个元素都是一个巨大的图像位图),那么您可能会看到这种影响(一种解决方法是对包装器对象进行排队,例如,有一个 ConcurrentQueue<StrongBox<T>>而不是一个ConcurrentQueue<T>,并且为null在包装器出队后,包装器对T值的引用).

据我所知,StrongBox是一种原始价值的包装.这是否意味着我必须存储另一个图像集合？

所以我正在寻找一个用法或一个例子ConcurrentQueue<StrongBox<T>>.我从谷歌找到的唯一的东西是这个代码.

我正在开发一个应用程序框架,Silverlight将在客户端使用,而.NET 4则在服务器端使用.在内部,框架具有字典和队列数据结构,其中多个线程将同时访问集合.

在服务器端,我想利用System.Collections.Concurrent命名空间中可用的ConcurrentDictionary和ConcurrentQueue类.但是,这些类未在Silverlight 4中实现.

我正在考虑的两种方法是:

1. 反编译ConcurrentDictionary和ConcurrentQueue类并在Silverlight类库中实现它们.这些将使用System.Collections.Concurrent命名空间作用域.
2. 在共享库中实现我需要的自定义线程安全集合类(或找到可靠的Silverlight线程安全集合实现),可以在服务器端和客户端使用.

第一种方法允许我只实现我需要的Silverlight数据结构,但我担心在我的Silverlight实现和.NET 4中实现的并发集合类之间引入差异.

第二种方法将在客户端和服务器端提供一致的并发集合实现,但感觉就像我将重新发明轮子.

在Silverlight 中实现ConcurrentDictionary和ConcurrentQueue类似乎并不困难,但是Silverlight已经有一个很好的线程安全集合类库？

我知道stop-the-world,incremental,parallel,concurrent,(soft/hard)实时垃圾收集器的概念.但我无法理解大多数并发 GC.与并发GC不同吗？有什么不同？为什么它主要被称为？

如何在.NET 4.0中对并发集合进行排序例如,我构建了ConcurrentBag集合.我如何对其中的元素进行排序？

ConcurrentBag<string> stringCollection;

ConcurrentBag<CustomType> customCollection;

我在Concurrent集合和线程中遇到麻烦,特别是在ConcurrentDictionary中使用AddOrUpdate方法基本上.....我无法使用它...我找不到任何好的例子...而且还没有完全理解,在MSDN编程指南中ConcurrentQueue的例子..

ConcurrentDictionary中的AddOrUpdate方法基本上.....我无法使用它...我找不到任何好的例子...而且也无法完全理解,在MSDN编程指南中的ConcurrentQueue示例..

初步情况

我正在开发.NET Framework 4.0,C#,Winform Application.应用程序将在GridView中列出(并测试)WebServiceOperations(当前有60个DataRows => WebServiceOperations).

目的

我只需点击一下按钮即可测试/调用所有这些操作.每个操作都会创建一个类的新实例.在这个类中,我调用WebServiceOperation异步并等待结果.结果随后得到验证.使用委托和事件,整个代码可以顺利运行.

现在谈到挑战/问题:当点击该按钮时,我使用for循环(int i = 0; i <gridViewWsOperations.RowCount; i ++)=>换句话说,目前我正在对它们进行60次操作'同时'=>服务器同时处理60个请求超载,我得到超时.所以我需要以某种方式限制结束请求的数量,让我们同时说10.考虑一下,for循环(我必须将请求排入队列)与我将请求出列的方法(process_result事件)不在同一个线程中.我尝试使用ConcurrentQueue,因为这种类型的集合似乎是线程安全的.

链接

MSDN上的ConcurrentQueue

示例代码真的会有所帮助!

---这是我的解决方案/示例代码---

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.Concurrent;
using System.Threading;

namespace ConcurrentQueueSample
{
    class Program
    {
        static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(3);

        static void Main(string[] args)
        {
            System.Timers.Timer timer = new System.Timers.Timer();
            timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
            timer.Interval = 1234;
            timer.Enabled = true;
            timer.Start();

            for (int i = 0; i < 10; i++) new Thread(go).Start(i);
        }

        static …

我需要在固定大小的FIFO队列周围实现生产者/消费者模式.我认为围绕ConcurrentQueue的包装类可能适用于此,但我不完全确定(我之前从未使用过ConcurrentQueue).这种扭曲是队列只需要保存固定数量的项目(在我的例子中是字符串).我的应用程序将有一个生产者任务/线程和一个消费者任务/线程.当我的消费者任务运行时,它需要在那个时刻出现队列中存在的所有项目并对其进行处理.

对于它的价值,我的消费者处理排队的项目只不过是通过SOAP将它们上传到一个不是100%可靠的网络应用程序.如果无法建立连接或调用SOAP调用失败,我应该丢弃这些项目并返回队列以获取更多信息.由于SOAP的开销,我试图最大化队列中可以在一次SOAP调用中发送的项目数.

有时,我的制作人可能会比我的消费者能够删除和处理它们更快地添加项目.如果队列已满并且我的生产者需要添加另一个项目,我需要将新项目排队,然后将最旧的项目出列,以便队列的大小保持固定.基本上,我需要始终保留队列中生成的最新项目(即使这意味着某些项目不会被消耗,因为我的消费者当前正在处理以前的项目).

关于生产者如果队列中的项目是固定的那样保留数字,我从这个问题中发现了一个潜在的想法:

固定大小队列,在新的enques上自动将旧值出列

我目前在ConcurrentQueue周围使用一个包装类(基于该答案)和Enqueue()方法,如下所示:

public class FixedSizeQueue<T>
{
    readonly ConcurrentQueue<T> queue = new ConcurrentQueue<T>();

    public int Size { get; private set; }

    public FixedSizeQueue(int size)
    {
        Size = size;
    }

    public void Enqueue(T obj)
    {
        // add item to the queue
        queue.Enqueue(obj);

        lock (this) // lock queue so that queue.Count is reliable
        {
            while (queue.Count > Size) // if queue count > max queue size, then dequeue an item
            {
                T objOut;
                queue.TryDequeue(out objOut);
            }
        } …