C# BlockingCollection.Dispose方法代码示例

        public void Start()
        {
            var ventilatorQueue = new BlockingCollection<WorkItem>();
            var sinkQueue = new BlockingCollection<WorkItem>();

            StartSink(sinkQueue);

            StartWorker(0, ventilatorQueue, sinkQueue);
            StartWorker(1, ventilatorQueue, sinkQueue);
            StartWorker(2, ventilatorQueue, sinkQueue);

            StartVentilator(ventilatorQueue);

            Thread.Sleep(1000);
            ventilatorQueue.CompleteAdding();
            sinkQueue.CompleteAdding();
            ventilatorQueue.Dispose();
            sinkQueue.Dispose();
        }

        /// <summary>
        /// Blocking collection acts as a threadsafe blocking queue
        /// </summary>
        public void BlockingCollection()
        {
            var queue = new BlockingCollection<string>();

            Task.Run(() =>
                {
                    while (true)
                    {
                        Console.Out.WriteLine(queue.Take());
                    }
                });

            for (int i = 0; i < 5; i++)
            {
                queue.Add(string.Format("item {0}", i));
                Thread.Sleep(1000);
            }

            queue.Dispose();
        }

//.........这里部分代码省略.........
                        {
                            skipSequence = true;
                        }
                        else
                        {
                            // if the sequence contains any gap symbols then ignore the sequence.
                            foreach (byte symbol in gapSymbols)
                            {
                                for (long index = 0; index < sequence.Count; ++index)
                                {
                                    if (sequence[index] == symbol)
                                    {
                                        skipSequence = true;
                                        break;
                                    }
                                }

                                if (skipSequence)
                                    break;
                            }
                        }

                        if (skipSequence)
                        {
                            Interlocked.Increment(ref _skippedSequencesCount);
                            Interlocked.Increment(ref _processedSequencesCount);
                            continue;
                        }

                        // if the blocking collection count is exceeding 2 million kmers wait for 2 sec 
                        // so that the task can remove some kmers and create the nodes. 
                        // This will avoid OutofMemoryException
                        while (kmerDataCollection.Count > stopAddThreshold)
                        {
                            Task.Delay(TimeSpan.FromSeconds(2)).Wait();
                        }

                        // Convert sequences to k-mers
                        kmerList.AddRange(KmerData32.GetKmers(sequence, KmerLength));

                        // Most reads are <=150 basepairs, so this should avoid having to grow the list
                        // by keeping it below blockSize
                        if (kmerList.Count > addThreshold)
                        {
                            kmerDataCollection.Add(kmerList);
                            kmerList = new List<KmerData32>(4092);
                        }
                        Interlocked.Increment(ref _processedSequencesCount);
                    }

                    if (kmerList.Count <= addThreshold)
                        kmerDataCollection.Add(kmerList);
                }
                finally
                {
                    kmerDataCollection.CompleteAdding();
                }
            });

            // Consume k-mers by addding them to binary tree structure as nodes
            Parallel.ForEach(kmerDataCollection.GetConsumingEnumerable(),newKmerList=>
            {
                foreach (KmerData32 newKmer in newKmerList)
                {
                    // Create Vertex
                    DeBruijnNode node = kmerManager.SetNewOrGetOld(newKmer);

                    // Need to lock node if doing this in parallel
                    if (node.KmerCount <= 255)
                    {
                        lock (node)
                        {
                            node.KmerCount++;
                        }
                    }
                }
            });

            // Ensure producer exceptions are handled.
            producer.Wait();

            // Done filling binary tree
            kmerDataCollection.Dispose();

            //NOTE: To speed enumeration make the nodes into an array and dispose of the collection
            _nodeCount = kmerManager.NodeCount;
            _nodes = kmerManager.GenerateNodeArray();
            
            // Generate the links
            GenerateLinks(kmerManager);
            
            // Since we no longer need to search for values set left and right nodes of child array to null
            // so that they are available for GC if no longer needed
            foreach (DeBruijnNode node in _nodes)
            {
                node.Left = node.Right = null;
            }

            GraphBuildCompleted = true;
        }