自身用调用移动的有具有批量抱物联网卡数据的接口。我索要调用移动的某具有批量沾物联网卡数据的接口。

BlockingCollection集合是一个享阻塞功能的会师,它就是成功了藏生产者消费者之算法功能。一般情形下,我们得因
生产者 – 消费者模式来促成产出。BlockingCollection<T>
类是无与伦比好的缓解方案

BlockingCollection集合是一个兼有阻塞功能的集合,它就是完结了藏生产者消费者之算法功能。一般情形下,我们可依据
生产者 – 消费者模式来兑现产出。BlockingCollection<T>
类是不过好之缓解方案

凑巧结束的物联网卡项目,我急需调用移动的某部具有批量得到物联网卡数据的接口,其实最关键的数码就是物联网卡卡号,然后经就半单卡号去调整用别样的蝇头独接口,最后拼接起来,就发生了物联网卡的整体信息。但是问题来了,物联网卡数量多,而且每次调用接口还需要费上一致到一定量秒,如果正常的读取,那不足慢死,所以便因故连作来做。我想到的是死队列+生产者消费者模型,使用的死队列是.net线程安全集合的BlockingCollection,
具体的可关押《你切莫能够错过.net
并作解决方案》《深入明阻塞队列》《.net
framework 4
线程安全概述》。
唯独问题来了,MSDN上之事例以及《C#
高级编程第九本》中之管道模型代码都是基于单个的Task,
在此我必是用了差不多个Task去读取接口,为什么自己而说马上点,多线程是不行测得,我怎么样鉴别阻塞队列已满,如何及时获得阻塞队列中之多寡,并无更的获取呢?具体的简便demo,请圈《公无能够错过.net
并作解决方案》。我一样开始是这么形容的:

恰恰结的物联网卡项目,我待调用移动的之一具有批量赢得物联网卡数据的接口,其实最好着重的数量就是是物联网卡卡号,然后通过这有限独卡号去调动用外的片单接口,最后拼接起来,就产生矣物联网卡的完好信息。但是问题来了,物联网卡数量多,而且每次调用接口还需要费上同一到个别秒,如果正常的读取,那不行慢死,所以即使因故连作来举行。我想到的凡死队列+生产者消费者模型,使用的堵塞队列是.net线程安全集合的BlockingCollection,
具体的可看《而切莫可知错过.net
并作解决方案》《深切理解阻塞队列》《.net
framework 4
线程安全概述》。
而问题来了,MSDN上的例证以及《C#
高级编程第九版》中之管道模型代码都是基于单个的Task,
在此处自己得是为此了差不多单Task去读取接口,为什么我一旦说就点,多线程是不可测得,我什么辨别阻塞队列已满,如何就获得阻塞队列中的多寡,并无重的抱呢?具体的简练demo,请圈《您不可知错过.net
并作解决方案》。我一样开始是如此写的:

BlockingCollection<string> blockingCollection = new BlockingCollection<string>();
            ConcurrentQueue<string> concurrentQueue = new ConcurrentQueue<string>();

            var t = new Task[50];
            for (int i = 0; i <= 49; i++)
            {
                t[i] = Task.Factory.StartNew((obj) =>
                {
                    Thread.Sleep(2500);
                    blockingCollection.Add(obj.ToString());
                    concurrentQueue.Enqueue(obj.ToString());
                    Console.WriteLine("Task中的数据: {0}", obj.ToString());
                }, i + 1);
            }

            Thread.Sleep(5000);
            while (!blockingCollection.IsCompleted)
            {
                foreach (var b in blockingCollection.GetConsumingEnumerable())
                {
                    Console.WriteLine("开始输出阻塞队列: {0}", b);
                    Console.WriteLine(blockingCollection.IsCompleted);
                    Console.WriteLine("并发队列的数量: {0}", concurrentQueue.Count);
                }

                Console.WriteLine("调用GetConsumingEnumerable方法遍历完之后阻塞队列的数量: {0}", blockingCollection.Count);

                if (concurrentQueue.Count == 50)
                {
                    blockingCollection.CompleteAdding();
                }
            }

            Console.WriteLine("********");

            Console.WriteLine("是否完成添加: {0}", blockingCollection.IsAddingCompleted);

            Console.Read();
BlockingCollection<string> blockingCollection = new BlockingCollection<string>();
            ConcurrentQueue<string> concurrentQueue = new ConcurrentQueue<string>();

            var t = new Task[50];
            for (int i = 0; i <= 49; i++)
            {
                t[i] = Task.Factory.StartNew((obj) =>
                {
                    Thread.Sleep(2500);
                    blockingCollection.Add(obj.ToString());
                    concurrentQueue.Enqueue(obj.ToString());
                    Console.WriteLine("Task中的数据: {0}", obj.ToString());
                }, i + 1);
            }

            Thread.Sleep(5000);
            while (!blockingCollection.IsCompleted)
            {
                foreach (var b in blockingCollection.GetConsumingEnumerable())
                {
                    Console.WriteLine("开始输出阻塞队列: {0}", b);
                    Console.WriteLine(blockingCollection.IsCompleted);
                    Console.WriteLine("并发队列的数量: {0}", concurrentQueue.Count);
                }

                Console.WriteLine("调用GetConsumingEnumerable方法遍历完之后阻塞队列的数量: {0}", blockingCollection.Count);

                if (concurrentQueue.Count == 50)
                {
                    blockingCollection.CompleteAdding();
                }
            }

            Console.WriteLine("********");

            Console.WriteLine("是否完成添加: {0}", blockingCollection.IsAddingCompleted);

            Console.Read();

只是结果:

只是结果:

可以看,这结果产生问题呀,按道理来讲foreach遍历完了不畏会下呀,但是及时是死队列,肯定不是如此的,那么什么时能够挑来foreach循环?这便和BlockingCollection的宏图有关了,我翻了下其的源码,原谅自己尚未看明白,也尽管非贴了。后来,我改变了产代码,就解决问题了。

可以看,这结果产生问题啊,按道理来讲foreach遍历完了就是会出呀,但是及时是死队列,肯定不是如此的,那么什么时会挑来foreach循环?这就是同BlockingCollection的设计有关了,我翻了下她的源码,原谅自己从不扣明白,也就是非贴了。后来,我转了生代码,就解决问题了。

BlockingCollection<string> blockingCollection = new BlockingCollection<string>();
            ConcurrentQueue<string> concurrentQueue = new ConcurrentQueue<string>();

            var t = new Task[50];
            for (int i = 0; i <= 49; i++)
            {
                t[i] = Task.Factory.StartNew((obj) =>
                {
                    Thread.Sleep(2500);
                    blockingCollection.Add(obj.ToString());
                    concurrentQueue.Enqueue(obj.ToString());
                    Console.WriteLine("Task中的数据: {0}", obj.ToString());
                }, i+1);
            }

            Thread.Sleep(5000);
            while (!blockingCollection.IsCompleted)
            {
                foreach (var b in blockingCollection.GetConsumingEnumerable())
                {
                    Console.WriteLine("开始输出阻塞队列: {0}", b);
                    Console.WriteLine(blockingCollection.IsCompleted);
                    Console.WriteLine("并发队列的数量: {0}", concurrentQueue.Count);
                    if (concurrentQueue.Count == 50)
                    {
                        blockingCollection.CompleteAdding();
                    }
                }
                Console.WriteLine("调用GetConsumingEnumerable方法遍历完之后阻塞队列的数量: {0}", blockingCollection.Count);

            }

            Console.WriteLine("********");

            Console.WriteLine("是否完成添加: {0}", blockingCollection.IsAddingCompleted);
BlockingCollection<string> blockingCollection = new BlockingCollection<string>();
            ConcurrentQueue<string> concurrentQueue = new ConcurrentQueue<string>();

            var t = new Task[50];
            for (int i = 0; i <= 49; i++)
            {
                t[i] = Task.Factory.StartNew((obj) =>
                {
                    Thread.Sleep(2500);
                    blockingCollection.Add(obj.ToString());
                    concurrentQueue.Enqueue(obj.ToString());
                    Console.WriteLine("Task中的数据: {0}", obj.ToString());
                }, i+1);
            }

            Thread.Sleep(5000);
            while (!blockingCollection.IsCompleted)
            {
                foreach (var b in blockingCollection.GetConsumingEnumerable())
                {
                    Console.WriteLine("开始输出阻塞队列: {0}", b);
                    Console.WriteLine(blockingCollection.IsCompleted);
                    Console.WriteLine("并发队列的数量: {0}", concurrentQueue.Count);
                    if (concurrentQueue.Count == 50)
                    {
                        blockingCollection.CompleteAdding();
                    }
                }
                Console.WriteLine("调用GetConsumingEnumerable方法遍历完之后阻塞队列的数量: {0}", blockingCollection.Count);

            }

            Console.WriteLine("********");

            Console.WriteLine("是否完成添加: {0}", blockingCollection.IsAddingCompleted);

结果:

结果:

本身没有写的特别详细,因为,只是做个记,平时上学的早晚没理会到这些题目,没有遇上一定情景下之问题,项目支出被相遇了,就记下下。

我没有写的不得了详细,因为,只是做只记,平时求学之早晚没有留意到这些问题,没有碰面一定情景下的题目,项目开发中相见了,就记录下。