【C#复习总结】探究各类数据结构(Array、List、Queue、Stack)及线程安全问题和yeild关键字

前言

先普及一下线程安全和类型安全

线程安全：

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。

线程安全问题都是由全局变量及静态标量引起的。

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

详见这篇文章：https://www.cnblogs.com/robin-zgp/articles/3150052.html

 

类型安全：

类型安全很大程度上可以等价于内存安全，类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言，其根据在于该门编程语言是否提供保障类型安全的机制；有的时候也用“类型安全”形容某个程序，判别的标准在于该程序是否隐含类型错误。类型安全的编程语言与类型安全的程序之间，没有必然联系。好的程序员可以使用类型不那么安全的语言写出类型相当安全的程序，相反的，差一点儿的程序员可能使用类型相当安全的语言写出类型不太安全的程序。绝对类型安全的编程语言暂时还没有。

一. 各类数据结构比较及其线程安全问题

1. Array(数组)：

分配在连续内存中,不能随意扩展，数组中数值类型必须是一致的。数组的声明有两种形式：直接定义长度，然后赋值；直接赋值。

缺点：插入数据慢。

优点：性能高，数据再多性能也没有影响

特别注意：Array不是线程安全，在多线程中需要配合锁机制来进行，如果不想使用锁，可以用ConcurrentStack这个线程安全的数组来替代Array。

{
                Console.WriteLine("---------------------------01 Array(数组)-----------------------------------");
                //模式一：声明数组并指定长度
                int[] array = new int[];
                //数组的赋值通过下标来赋值
                for (int i = ; i < array.Length; i++)
                {
                    array[i] = i + ;
                }
                //数组的修改通过下标来修改
                array[] = ;
                //输出
                for (int j = ; j < array.Length; j++)
                {
                    Console.WriteLine(array[j]);
                }

                //模式二：直接赋值
                string[] array2 = new string[] { "二胖", "二狗" };
}

2. ArrayList(可变长度的数组)

不必在声明的时候指定长度,即长度可变；可以存放不同的类型的元素。

致命缺点：无论什么类型存到ArrayList中都变为object类型，使用的时候又被还原成原先的类型，所以它是类型不安全的，当值类型存入的时候，会发生装箱操作，变为object引用类型，而使用的时候，又将object类型拆箱，变为原先的值类型，这尼玛，你能忍？

结论：不推荐使用，建议使用List代替！！

特别注意：ArrayList不是线程安全，在多线程中需要配合锁机制来进行。

{
                Console.WriteLine("---------------------------02 ArrayList(可变长度的数组)-----------------------------------");
                ArrayList arrayList = new ArrayList();
                arrayList.Add("二胖");
                arrayList.Add("马茹");
                arrayList.Add();
                for (int i = ; i < arrayList.Count; i++)
                {
                    Console.WriteLine(arrayList[i] + "类型为：" + arrayList[i].GetType());
                }
}

3. List<T> (泛型集合) 推荐使用

内部采用array实现，但没有拆箱和装箱的风险，是类型安全的

特别注意：List<T>不是线程安全，在多线程中需要配合锁机制来进行，如果不想使用锁，可以用ConcurrentBag这个线程安全的数组来替代List<T>

{
                Console.WriteLine("---------------------------03 List<T> (泛型集合)-----------------------------------");
                List<string> arrayList = new List<string>();
                arrayList.Add("二胖");
                arrayList.Add("马茹");
                arrayList.Add("大胖");
                //修改操作
                arrayList[] = "葛帅";
                //删除操作
                //arrayList.RemoveAt(0);
                for (int i = ; i < arrayList.Count; i++)
                {
                    Console.WriteLine(arrayList[i]);
                }
}

4. LinkedList<T> 链表

在内存空间中存储的不一定是连续的，所以和数组最大的区别就是，无法用下标访问。

优点：增加删除快，适用于经常增减节点的情况。

缺点：无法用下标访问，查询慢，需要从头挨个找。

特别注意：LinkedList<T>不是线程安全，在多线程中需要配合锁机制来进行。

{
                Console.WriteLine("---------------------------04 ListLink<T> 链表-----------------------------------");
                LinkedList<string> linkedList = new LinkedList<string>();
                linkedList.AddFirst("二胖");
                linkedList.AddLast("马茹");

                var node1 = linkedList.Find("二胖");
                linkedList.AddAfter(node1, "三胖");
                //删除操作
                linkedList.Remove(node1);
                //查询操作
                foreach (var item in linkedList)
                {
                    Console.WriteLine(item);
                }
}

5. Queue<T> 队列

先进先出，入队(Enqueue)和出队(Dequeue)两个操作

特别注意：Queue<T>不是线程安全，在多线程中需要配合锁机制来进行，如果不想使用锁，线程安全的队列为 ConcurrentQueue。

实际应用场景：利用队列解决高并发问题

{
                Console.WriteLine("---------------------------05 Queue<T> 队列-----------------------------------");
                Queue<int> quereList = new Queue<int>();
                //入队操作
                for (int i = ; i < ; i++)
                {
                    quereList.Enqueue(i + );
                }
                //出队操作
                while (quereList.Count != )
                {
                    Console.WriteLine(quereList.Dequeue());
                }
}

6. Stack<T> 栈

后进先出，入栈（push）和出栈（pop）两个操作

特别注意：Stack<T>不是线程安全

{
                Console.WriteLine("---------------------------06 Stack<T> 栈-----------------------------------");
                Stack<int> stackList = new Stack<int>();
                //入栈操作
                for (int i = ; i < ; i++)
                {
                    stackList.Push(i + );
                }
                //出栈操作
                while (stackList.Count != )
                {
                    Console.WriteLine(stackList.Pop());
                }
}

7. Hashtable

典型的空间换时间，存储数据不能太多，但增删改查速度非常快。

特别注意：Hashtable是线程安全的，不需要配合锁使用。

{
                Console.WriteLine("---------------------------07 Hashtable-----------------------------------");
                Hashtable tableList = new Hashtable();
                //存储
                tableList.Add("", "马茹");
                tableList[""] = "二胖";
                //查询
                foreach (DictionaryEntry item in tableList)
                {
                    Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString());
                }
}

8. Dictionary<K,T>字典 （泛型的Hashtable）

增删改查速度非常快，可以用来代替实体只有id和另一个属性的时候，大幅度提升效率。

特别注意：Dictionary<K,T>不是线程安全，在多线程中需要配合锁机制来进行，如果不想使用锁，线程安全的字典为 ConcurrentDictionary。

{
                Console.WriteLine("---------------------------08 Dictionary<K,T>字典-----------------------------------");
                Dictionary<string, string> tableList = new Dictionary<string, string>();
                //存储
                tableList.Add("", "马茹");
                tableList.Add("", "二胖");
                tableList[""] = "三胖";
                //查询
                foreach (var item in tableList)
                {
                    Console.WriteLine("key:{0},value:{1}", item.Key.ToString(), item.Value.ToString());
                }
}

强调： 

以上8种类型，除了Hashtable是线程安全，其余都不是，都需要配合lock锁来进行，或者采用 ConcurrentXXX来替代。

二. 四大接口比较

1. IEnumerable

是最基本的一个接口，用于迭代使用，里面有GetEnumerator方法。

2. ICollection

继承了IEnumerable接口，主要用于集合，内部有Count属性表示个数，像ArrayList、List、LinkedList均实现了该接口。

3. IList

继承了IEnumerable 和 ICollection,实现IList接口的数据接口可以使用索引访问，表示在内存上是连续分配的，比如Array、List。

4. IQueryable

这里主要和IEnumerable接口进行对比。

Enumerable里实现方法的参数是Func委托，Queryable里实现的方法的参数是Expression表达式。

实现IQueryable和IEnumabler均为延迟加载，但二者的实现方式不同，前者为迭代器模式，参数为Func委托，后者为Expression表达式目录树实现。

三. yield关键字

1. yield必须出现在IEunmerable中

2. yield是迭代器的状态机，能做到延迟查询，使用的时候才查询，可以实现按序加载

3. 例子

　　测试一：在 “var data1 = y.yieldWay();”加一个断点，发现直接跳过，不能进入yieldWay方法中，而在“foreach (var item in data1)”加一个断点，第一次遍历的时候就进入了yieldWay方法中，说明了yield是延迟加载的，只有使用的时候才查询。

　　测试二：对yieldWay和commonWay获取的数据进行遍历，通过控制台发现前者是一个一个输出，而后者是先一次性获取完，一下全部输出来，证明了yield可以做到按需加载，可以在foreach中加一个限制，比如该数据不满足>100就不输出。

//*********************************  下面为对比普通返回值和使用yeild返回值的方法  ************************************************

       /// <summary>
       /// 含yield返回值的方法
       /// </summary>
       /// <returns></returns>
        public IEnumerable<int> yieldWay()
        {
            for (int i = ; i < ; i++)
            {
                yield return this.Get(i);
            }
        }
        /// <summary>
        /// 普通方法
        /// </summary>
        /// <returns></returns>
        public IEnumerable<int> commonWay()
        {
            int[] intArray = new int[];
            for (int i = ; i < ; i++)
            {
                intArray[i] = this.Get(i);
            }
            return intArray;
        }

        /// <summary>
        /// 一个获取数据的方法
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        private int Get(int num)
        {
            Thread.Sleep();
            return num * DateTime.Now.Second;
        }

Console.WriteLine("-----------------------下面是调用yield方法-----------------------");
            yieldDemo y = new yieldDemo();
            var data1 = y.yieldWay();
            foreach (var item in data1)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine("-----------------------下面是调用普通方法-----------------------");
            var data2 = y.commonWay();
            foreach (var item in data2)
            {
                Console.WriteLine(item);
            }

注：本文参考http://www.cnblogs.com/yaopengfei/p/9007336.html，侵删。