通俗感性多线程学习

从现在开始，一直到下班之前，什么也不干了，就是把这个多线性深刻理解下。

然后剩余的时间就可以自己玩了，哈哈哈。

开始吧，come on：

.......

下班之前总结在此。

累......

下面代码是，简单单线程执行：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ThearedTet
{
    class Program
    {
        static void Main(string[] args)
        {
            //添加一个搬家的人家，并签订合同
            HouseMovingCompany.Instance.Contract.Add(new Contract { From = "11111 ",To = "2222222",Fee = 500});
            HouseMovingCompany.Instance.Contract.Add(new Contract { From = "22222", To = "33333333", Fee = 500 });
            HouseMovingCompany.Instance.Contract.Add(new Contract { From = "33333333 ", To = "4444444", Fee = 500 });
            HouseMovingCompany.Instance.Contract.Add(new Contract { From = "4444444 ", To = "55555555", Fee = 500 });

            //判断如果合同不是0，则一直到执行里面的搬家方法
            while (HouseMovingCompany.Instance.Contract.Count > 0)
            {
                HouseMovingCompany.Instance.MoveHouse();
            }

            return;

        }
    }

    //类
    public class Contract
    {
        //定义属性
        public string ID
        {
            get;
            private set;
        }
        public string From
        {
            get;
            set;
        }
        public string To
        {
            get;
            set;
        }
        //定义一个表示十进制的变量Fee来表示费用
        public decimal Fee
        {
            get;
            set;
        }

        //定义构造函数
        public Contract()
        {
            this.ID = Guid.NewGuid().ToString();
            //GUID：globally unique identifier(GUID——全局唯一标识符) 
            //分配给COM对象的标识符(ID)。
            //它通过一种复杂的算法生成,该算法保证所有的COM对象都有着唯一的ID,而不会出现名字冲突
        }
    }

    //申请类
    public class HouseMovingCompany
    {
        //创建一个实例
        private static  HouseMovingCompany _instance = null;
        public static HouseMovingCompany Instance
        {
            get 
            { 
                return (_instance == null ? _instance = new HouseMovingCompany() : _instance);
            }
        }

        //定义一个类类型的列表
        public List<Contract> Contract { get; private set; }

        //构造函数，用来初始化对象，其实就是来实例化一个列表容器
        public HouseMovingCompany()
        {
            this.Contract = new List<Contract>();
        }

        //定义方法
        public void MoveHouse()
        {
            if (this.Contract == null || this.Contract.Count == 0)
            {
                return;
            }
            //得到容器中的第一个内容，或者说就是第一个需要搬家的人的合同书
            //要逐个显示容器中的条目，可以通过下面的这两句，就是赋值一条，删除该条，计数自动减少。
            Contract contract =  this .Contract [0];
            this.Contract.RemoveAt(0);

            if (!String.IsNullOrEmpty(contract.From) && !String.IsNullOrEmpty(contract.To))
            {
                Console.WriteLine("Move the house from {0} to {1}.",contract .From,contract .To );
             }

            Thread.Sleep(5000);
        }

    }
}

下面是多线程实现：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ThearedTet
{
    class Program
    {
        static void Main(string[] args)
        {
            //添加一个搬家的人家，并签订合同
            HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "11111 ",To = "2222222",Fee = 500});
            HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "22222", To = "33333333", Fee = 500 });
            HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "33333333 ", To = "4444444", Fee = 500 });
            HouseMovingCompany.Instance.Contracts.Add(new Contract { From = "4444444 ", To = "55555555", Fee = 500 });

            
            Thread thread = null;                             //创建线程

            //判断如果合同不是0，则一直到执行里面的搬家方法
            while (HouseMovingCompany.Instance.Contracts.Count > 0)
            {
                //HouseMovingCompany.Instance.MoveHouse();
                thread = new Thread(new ThreadStart (HouseMovingCompany .Instance .MoveHouse));

                thread.Start();
            }

            return;

        }
    }

    //类
    public class Contract
    {
        //定义属性
        public string ID
        {
            get;
            private set;
        }
        public string From
        {
            get;
            set;
        }
        public string To
        {
            get;
            set;
        }
        //定义一个表示十进制的变量Fee来表示费用
        public decimal Fee
        {
            get;
            set;
        }

        //定义构造函数
        public Contract()
        {
            this.ID = Guid.NewGuid().ToString();
            //GUID：globally unique identifier(GUID——全局唯一标识符) 
            //分配给COM对象的标识符(ID)。
            //它通过一种复杂的算法生成,该算法保证所有的COM对象都有着唯一的ID,而不会出现名字冲突
        }
    }

    //申请类
    public class HouseMovingCompany
    {
        //创建一个实例
        private static  HouseMovingCompany _instance = null;
        public static HouseMovingCompany Instance
        {
            get 
            { 
                return (_instance == null ? _instance = new HouseMovingCompany() : _instance);
            }
        }

        //定义一个类类型的列表
        public List<Contract> Contracts { get; private set; }

        //构造函数，用来初始化对象，其实就是来实例化一个列表容器
        public HouseMovingCompany()
        {
            this.Contracts = new List<Contract>();
        }

        //定义方法
        public void MoveHouse()
        {
            if (this.Contracts == null || this.Contracts.Count == 0)
            {
                return;
            }
            //得到容器中的第一个内容，或者说就是第一个需要搬家的人的合同书
            //要逐个显示容器中的条目，可以通过下面的这两句，就是赋值一条，删除该条，计数自动减少。
            Contract contract = null;

            lock (this.Contracts)
            {
                contract = this.Contracts[0];
                this.Contracts.RemoveAt(0);
            }
            if (!String.IsNullOrEmpty(contract.From) && !String.IsNullOrEmpty(contract.To))
            {
                Console.WriteLine("Move the house from {0} to {1}.",contract .From,contract .To );
             }

            Thread.Sleep(5000);
        }

    }
}

总结上面两个代码的实现，或者说功能的实现，首先从感性的角度看到所谓的单线程和多线程执行的效率，或者说时间的长短可以看到各自的优势。

执行效果可以很明显的看得出来，使用多线程机制的执行效率明显提升。或者说执行的时间明显缩短。

也就是说，多线程执行，几乎同时执行搬家这个方法，然后执行搬家方法最后的一句Thread.Sleep(5000);

参考资料地址：http://www.cnblogs.com/Autumoon/archive/2008/06/19/1225684.html