编辑和更新 -我现在在我的个人计算机上尝试了相同的代码，它工作得非常好。我能够使用相同的代码复制任何类型的文件而没有任何问题。当我在我的工作计算机上运行代码时，我遇到了这个问题。我只是不明白这如何以及为什么这取决于计算机。请让我知道我是否在这里遗漏了什么。

在 readTask 中，我按顺序读取文件并将字节添加到 BlockingCollection。在消费任务中，我正在读取 BlockingCollection 中出现的数据并将其写入文件。因为，默认情况下，BlockingCollection 是 ConcurrentQueue 的包装器，我希望从阻塞队列中读取的顺序与写入它的顺序相同。但是当我将目标文件与源文件进行比较时，它完全不同，有时我会看到重复。
我的源文件只是一个数字序列，每个数字都在新行上，如下所示。

在我的文件中，我有大约 5000 个数字让文件有足够的大小。这段代码有问题吗？或者这不是阻止收集应该起作用的方式。在此示例中，我正在写入文件，但实际上我需要将此文件推送到 Rest API，并且按顺序发送数据很重要。如果字节不能按顺序发送，则文件存储在服务器上时将损坏。

I want to create a cache in my web application, which will allow the top layer (MVC) to persist some values, retrieved from underlying layers (services & DB), in order to avoid unnecessary requests to it. The data, that I want to store in cache, is needed on every page of the web site, so this cache is aimed to dramatically reduce the amount of requests. The idea is that a lot of threads will read the data from collection while one thread will clear it and retrieve new data after cache expiration. This means the collection will be used for frequent reading and rare writing operations.

The problem for me is to choose the appropriate class for these purposes. I have read about the set of concurrent classes from System.Collections.Concurrent, introduced in .NET 4. I definitely don't need to use ConcurrentQueue or ConcurrentStack, but I have to choose between BlockingCollection, ConcurrentBag and ConcurrentDictionary.

ConcurrentBag seems to be the best solution in this case. However, I read in this article that concurrent dictionary

... is entirely lock-free for read operations. In this way, it’s optimized for scenarios where reading from the dictionary is the most frequent operation.

So maybe the best solution is to use ConcurrentDictionary<int, MyTypeOfObj> instead? Or maybe I don't need concurrent type at all and simple List will do the job? Probably, it would do if I can somehow lock operations with it for the time of cache update. But using simple lock is undesirable.

Any advices and explanations are appreciated.

Update

The cache is used to store the map points of the outlets. The set of outlets is quite stable, but there should be a UI to add them, so insert operations are really rare. It might be even easier to retrieve whole collection from the underlying layer after timeout then perform insert operations. Search is not required as well, reading means simple enumeration.

Is Concurrent Collections are thread safe when we use them in linq queries? and what is the difference between Concurrent Collection and Immutable Collections??

在分析之后，我发现我的应用程序中的特定对象将通过使用对象池而不是构造它而受益匪浅。此应用程序基于具有多个线程的生产者/消费者队列。

ConcurrentBag 集合基本上是一个 ObjectPool，看起来非常适合作为应用程序对象池的后备存储。如果我理解正确，ConcurrentBag 在概念上是这样工作的：

1. 保留袋装对象的 ThreadLocal 集合。插入时添加到此集合，移除时从此集合中移除。
2. 如果本地集合中没有元素并且必须删除一个对象，则从另一个线程的本地集合中窃取一个。

问题是我已经知道应用程序将始终在线程“A”上请求对象，并始终在线程“B”上返回它。因此，它将始终默认为窃取案例。

了解了这种访问模式，使用框架提供的不同集合来支持对象池会更好吗？

我正在创建一个封装 ConcurrentDictionary 的自定义集合。我发现了很多关于从通用集合封装/继承的信息，但没有特定于并发集合的信息。这是我的基本案例的代码片段，然后是一些一般性问题。

• 以这种方式封装并发集合是否可以接受，或者这是否正在进入从通用集合创建自己的线程安全集合的领域？
• 自定义集合是线程安全的吗？
• 继承并发集合是否可以接受？像这样，如果是这样class ItemCollection : ConcurrentDictionary<string, Item>，有什么准则，类似于从非并发集合继承的准则。
• 您如何为 Select 等方法实现转发方法？我尝试了以下一系列变体，但无法使其正常工作：

public IEnumerable<TResult> Select<ItemCollection, TResult>(this ItemCollection source, Func<KeyValuePair<string, Item>, TResult> selector) { return Collection.Select(selector); }

如果我继承 ConcurrentDictionary 它会导致类似的实现

所以下面的代码将每秒转储整个列表。

但是我怎样才能让它只更新转储输出而不添加新的呢？

这里有一个相关的问答，但它对我不起作用。

我现在正在学习并发性，并且我尝试编写一个程序，该程序应该在使用并发收集时演示发生之前的关系。如java.concurrent包中所述：

java.util.concurrent 及其子包中所有类的方法将这些保证扩展到更高级别的同步。特别是：在将对象放入任何并发集合之前的线程中的操作发生在另一个线程中从集合中访问或删除该元素之后的操作之前。

我写了下一节课：

我所做的是启动thread1，它启动thread2。Thread1 检查最初设置为 false 的公共布尔varToHappenBefore 。当 thread1 从集合中保存新的元素时，它将这个布尔值设置为 true。在下一个新元素上。接收这个布尔值是否仍然为真，发生在违规发生之前，并且shouldNotHappen递增。

Thread1 检查并发集合是否有新元素，如果有，将其保存在 temp var 中并增加整体计数器检查。然后它切换原子布尔值以让 thread2 添加新元素。在添加新元素之前，varToHappenBefore设置为 false。由于原子布尔标志，thread2 不会在 thread1 之前运行代码。但是在 thread2 中切换标志是在添加元素和检查varToHappenBefore之前完成的，因为这两个操作（elem add 和 boolean toggle）否则通过 atomic boolean 同步。我确保 thread2 在 thread1 运行后只运行一次。如果varToHappenBefore发生在添加元素之前。在thread2中收集，然后在thread1中读取（thread1检查varToHappenBefore仅当从集合中读取新元素时），那么varToHappenBefore必须在程序结束后保持为 0。但我得到下一个结果：

添加元素次数：~10 000 000

违规前发生次数：0-10

可能我做错了什么，多线程是微妙而复杂的。希望得到您的帮助。

编辑：setFlag(false)我需要在thread1为真之后和获得elem之前 逃避这种情况。从集合中，因为thread2然后可以在从集合中获取元素和varToHappenBefore = true;在线程1中设置之间工作。如果我进行 AtomicBoolean.compareAndSet()检查块，那么我每8mils得到80k失败。它是可预测的和清晰的。但是，当我没有为 thread2 设置这样的窗口以在从集合读取和设置布尔值之间添加其他元素时，当布尔值为 true 并且出现新元素时，我仍然得到很少的顺序读取。

我必须编写一个程序，从数据库中读取要处理的队列，并且所有队列都并行运行并使用 ConcurrentDictionary 在父线程上进行管理。我有一个代表队列的类，它有一个接受队列信息和父实例句柄的构造函数。队列类也有处理队列的方法。

这是队列类：

父线程循环遍历队列数据集并实例化一个新的队列类。它产生一个新线程来异步执行 Queue 对象的 Process 方法。将此线程添加到 ConcurrentDictionary 中，然后按如下方式启动：

我觉得这不是管理异步队列处理的正确方法，我想知道这种设计是否会陷入死锁？此外，我想使用任务来异步运行队列而不是新线程。我需要跟踪队列，因为如果上一次运行尚未完成，我不会为同一个队列生成新线程或任务。处理这种并行性的最佳方法是什么？

提前致谢！

假设我有ConcurrentDictionary<int, HashSet<int>> sampleCollection;. sampleCollection[1]对（这是 a ）执行操作是否是线程安全的HashSet<int>？

一般来说，如果我们在一个线程安全的集合里面有一个非线程安全的集合，那么通过线程安全的外层来操作这个非线程安全的集合是线程安全的吗？

当前的实现如下所示：

有谁知道为什么它也没有实施ICollection<T>？有点烦人...