List和Queue使用过程中的纪录

      业务需求： 发送特定的请求，根据返回的信息执行特定的事件。

      目前的做法：把我的请求放入一个容器内，然后待到某一条件，就从这个容器把请求发送出去，等客户返回信息时，查询容器中对应请求中特定的事件。开始的时候我使用 List .其中遇到一些问题，纪录一下

namespace CollSecExp
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list = new List<int>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(i);
            }

            Thread t1 = new Thread(() =>
            {
                 foreach (var item in list)
                 {
                     Console.WriteLine("t1.item:{0}", item);
                     Thread.Sleep(1000);
                 }
            });
            t1.Start();

            Thread t2 = new Thread(() =>
            {
                Thread.Sleep(1000);
                list.RemoveAt(1);
                list.RemoveAt(3);
                foreach (var item in list)
                {
                     Console.WriteLine("t2.item:{0}", item);
                 }
            });
            t2.Start();
        }
    }
}

       运行会抛出InvalidOperationException异常，提示“集合已修改；可能无法执行枚举操作。”

这是因为，线程2移除index=1，3的元素导致集合被修改。使用加锁

namespace CollSecExp
{
    class Program
    {
        static void Main(string[] args)
        {
            object sycObj = new object();
            List<int> list = new List<int>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(i);
            }

            Thread t1 = new Thread(() =>
            {
                lock (sycObj)
                {
                    foreach (var item in list)
                    {
                        Console.WriteLine("t1.item:{0}", item);
                        Thread.Sleep(1000);
                    }
                }
            });
            t1.Start();

            Thread t2 = new Thread(() =>
            {
                Thread.Sleep(1000);
                lock (sycObj)
                {
                    list.RemoveAt(1);
                    list.RemoveAt(3);
                    foreach (var item in list)
                    {
                        Console.WriteLine("t2.item:{0}", item);
                    }
               }
            });
            t2.Start();
        }
    }
}

        加锁就可以解决了。

        后来使用了想起了对于请求，我们可以使用队列，最简单的请求Queue如下 

static void Main(string[] args)
        {
            int count = 0;
            Queue<int> queue = new Queue<int>();
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    Thread.Sleep(3000);
                    Console.WriteLine("生产的元素是： " + count);
                    queue.Enqueue(count);
                    count++;

                }

            });

            ;
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    if (queue.Count > 0)
                    {
                        int value = queue.Dequeue();
                        Console.WriteLine("worker1 " + ": 消费的元素是： " + value);
                    }
                }

            });

            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    if (queue.Count > 0)
                    {
                        int value = queue.Dequeue();
                        Console.WriteLine(Thread.CurrentThread + " : 消费的元素是： " + value);
                    }
                }

            });


            Console.ReadKey();

        }

     由于没有加锁或是其他机制，那么很容易出错，于是改进了版本。

        static void Main(string[] args)
        {
            int count = 0;
            var queue = new ConcurrentQueue<int>();
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    Thread.Sleep(1000);
                    Console.WriteLine("生产的元素是： " + count);
                    queue.Enqueue(count);
                    count++;

                }

            });

            ;
            Task.Factory.StartNew(() =>
            {
                while (true)
                {

                    int value;
                    if (queue.TryDequeue(out value))
                    {
                        Console.WriteLine("worker1 " + ": 消费的元素是： " + value);
                    }

                }

            });

            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    int value;
                    if (queue.TryDequeue(out value))
                    {
                        Console.WriteLine("worker2 " + " : 消费的元素是： " + value);
                    }
                }

            });

       执行这段代码，可以工作，但是有点不太优雅，能不能不要去判断集合是否为空？集合当自己没有元素的时候自己Block一下可以吗？答案当然是可以的，使用BlockingCollection即可：

        static void Main(string[] args)
        {
            int count = 0;
            var queue = new BlockingCollection<int>();
            var product = Task.Factory.StartNew(() =>
              {
                  for (int i = 20 - 1; i >= 0; i--)
                  {
                      Console.WriteLine("生产的元素是： " + count);
                      queue.Add(count);
                      count++;
                  }

              });


            var consumer1 = Task.Factory.StartNew(() =>
              {
                  foreach (int value in queue.GetConsumingEnumerable())
                  {
                      Console.WriteLine("worker1 " + ": 消费的元素是： " + value);

                  }

              });

            var consumer2 = Task.Factory.StartNew(() =>
              {
                  foreach (int value in queue.GetConsumingEnumerable())
                  {
                      if (value % 2 == 0)
                      {
                          Console.WriteLine("worker2 " + " : 消费的元素是： " + value);
                      }
                      else
                      {
                          queue.Add(value);
                      }
                  }
              });
            Task.WaitAny(product, consumer2, consumer1);
            Console.ReadKey();
        }

      当我需要控制Queue停止反复遍历获取queue是否存在元素时，可以使用如下方法，同时在构造方法中可以指定队列的大小

blockingCollection.CompleteAdding();

参考文章：

C#的变迁史 - C# 4.0 之线程安全集合篇

List