c#多线程开发

        //要执行的业务是从阿里云上下载将近40000条的音频到本地，单条下载忒慢，就想采用多线程，分配了二十个线程同时下载，省了很大部分的时间

          class Program
    {
       
        static void Main(string[] args) {
            string sql = "select en_audio,us_audio from t_audio LIMIT 198 ";
            MySqlDataReader mySqlDataReader = DBHelper.ExecuteReader(sql);         
            List<String> sList = new List<String>();
            sList.Add("https://qutifen-qudao.oss-cn-beijing.aliyuncs.com/mfg/audio/v3/1abacus_en.ogg");
            sList.Add("https://qutifen-qudao.oss-cn-beijing.aliyuncs.com/mfg/audio/v3/2abacus_en.ogg");
            if (mySqlDataReader.HasRows)
            {
                while (mySqlDataReader.Read())
                {                 
                    sList.Add(mySqlDataReader.GetString(0));
                    sList.Add(mySqlDataReader.GetString(1));
                }
            }              
            Console.WriteLine(sList.Count);
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            ThreadStart(sList);
            WaitHandle.WaitAll(waits);  //监听wait里面的所有的线程都已经set了 才执行下面的代码，否则一直在这里等待
            stopwatch.Stop();
            Console.WriteLine($"耗时{stopwatch.ElapsedMilliseconds}毫秒");
            Console.ReadKey();


        }
       static  Thread[] threads = new Thread[20];
        static WaitHandle[] waits = new WaitHandle[20];
        public  static void ThreadStart(List<String> nums) {
                  //分配线程
            for (int i=0;i<20;i++) {
                threads[i] = new Thread(DownLoadFile);
                waits[i] = new AutoResetEvent(false);

            }
                 //为每个线程分配要执行的数据并开始执行
            for (int i = 0; i < 20; i++)
            {
                if (i== threads.Length-1) {
                    var retult = nums.Skip(nums.Count / 20 * i).Take(nums.Count- nums.Count / 20*i).ToList();
                    threads[i].Start(new Objpt()
                    {
                        sList = retult,
                        WaitHandle = waits[i],
                        ThreadIndex = i
                    });
                }
                else {
                  var retult= nums.Skip(nums.Count / 20 * i).Take(nums.Count / 20).ToList();
                    threads[i].Start(new Objpt() { 
                     sList= retult,
                     WaitHandle=waits[i],
                     ThreadIndex=i
                    });
                }
               
            }
        }

        public static void DownLoadFile(Object obj)
        {
            int count = 0;
            Objpt optObj = (obj as Objpt);
            var sList = optObj.sList;
            Console.WriteLine($"线程{optObj.ThreadIndex}开始了");
            foreach (var url in sList)
            {
                try
                {
                    count++;
                    var arrs = url.Split('/');
                    WebRequest request = WebRequest.Create(url);
                    HttpWebResponse res = (HttpWebResponse)request.GetResponse();
                    WebResponse response = request.GetResponse();           
                    if (res.StatusCode.ToString() == "OK")
                    {
                        Stream responseStream = response.GetResponseStream();
                        using (FileStream fsWrite = new FileStream($"F:/Audio/v4/{arrs[arrs.Length - 2]}/{arrs[arrs.Length - 1]}", FileMode.OpenOrCreate, FileAccess.Write))
                        {
                            byte[] buffer = new byte[response.ContentLength];
                            while (true)
                            {
                                ////返回本次实际读取到的字节数
                                int r = responseStream.Read(buffer, 0, buffer.Length);
                                if (r == 0)
                                {
                                    break;
                                }
                                fsWrite.Write(buffer, 0, r);///写入

                            }
                        }
                    }
                    //if (count % 20 == 0 || count == sList.Count)
                    //{
                    //    Console.WriteLine($"线程{optObj.ThreadIndex}已处理个数：{count}");
                    //}

                }
                catch (Exception ex)
                {
                    string strErrorLogFile = System.AppDomain.CurrentDomain.BaseDirectory + $"\{optObj.ThreadIndex}ErrorLog.log";
                    if (!System.IO.File.Exists(strErrorLogFile))
                        System.IO.File.WriteAllText(strErrorLogFile, "//系统错误日志记录文件
");
                    object objSql ="线程"+ optObj.ThreadIndex.ToString()+ ex.Message;
                    System.IO.File.AppendAllText(strErrorLogFile, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + "	" + objSql.ToString() + url + "
");

                }

            }
            Console.WriteLine($"线程{optObj.ThreadIndex}结束");
            (optObj.WaitHandle as AutoResetEvent).Set();  //set方法是当某个线程结束起做个标记的作用
        }
    }

     public class Objpt {
        public List<String> sList { get; set; }
        public WaitHandle WaitHandle { get; set; }
        public int ThreadIndex { get; set; }

    }

private static AutoResetEvent myAutoRetEvent = new AutoResetEvent(false);
// true:设置终止状态（不阻塞）。相当于调用了Set(),即首次不会被WaitOne()阻塞，下次执行WaitOne()才会被阻塞
//false:设置非终止状态（阻塞）。遇到WaitOne()立即阻塞所在的一个或多个线程

//public bool Set();  //将事件状态设置为终止状态，从而允许继续执行一个或多个等待线程。
//public bool Reset();//将事件状态设置为非终止，从而导致线程受阻。

static void Main(string[] args)
{
//来了一个顾客1
Thread myThread1 = new Thread(new ThreadStart(Run_1));
myThread1.Start();
//来了一个顾客2
Thread myThread2 = new Thread(new ThreadStart(Run_2));
myThread2.Start();

//厨师做饭做3000ms
Thread.Sleep(3000);
//厨师做好饭了，通知看谁能吃上饭
myAutoRetEvent.Set(); //Run_2不会被执行，只有Run_1执行
Console.ReadKey();
}

private static void Run_1()
{
//顾客1过来了，要吃饭，等厨师做好饭
myAutoRetEvent.WaitOne();
Console.WriteLine("我是顾客1开始吃饭...");

}

private static void Run_2()
{
//顾客2过来了，要吃饭，等厨师做好饭
myAutoRetEvent.WaitOne();
Console.WriteLine("我是顾客2开始吃饭...");
}

等待3秒后，弹出“我是顾客1开始吃饭...”，如果把构造函数中的false改为true，单击按钮后，立即弹出“我是顾客1开始吃饭...”。

.ManualResetEvent 调用一次Set()后将允许恢复所有被阻塞线程,即Run_1，Run_2都会被执行；
.AutoResetEvent,调用一次Set()只能继续被阻塞的一个线程，即Run_2不会被执行，只有Run_1执行，多次调用Set()才行 

AutoResetEvent和ManualResetEvent实例化，如果为 true，则将初始状态设置为终止（不阻塞）；如果为 false，则将初始状态设置为非终止（阻塞）。

//将事件状态设置为终止状态，从而允许继续执行一个或多个等待线程。
//public bool Set();
//将事件状态设置为非终止，从而导致线程受阻。
//public bool Reset();

http://blog.sina.com.cn/s/blog_6f19490b0102x4c4.html

WaitOne：在一个线程MainThread中开启一个新的线程NewThread，在完成初始化并启动NewThread的操作后，调用WaitOne，则MainThread堵塞，直到在NewThread中调用Set，MainThread才继续执行。

AutoResetEvent 允许线程通过发信号互相通信。通常，此通信涉及线程需要独占访问的资源。

线程通过调用 AutoResetEvent 上的 WaitOne 来等待信号。如果 AutoResetEvent 处于非终止状态，则该线程阻塞，并等待当前控制资源的线程通过调用 Set 发出资源可用的信号。

调用 Set 向 AutoResetEvent 发信号以释放等待线程。AutoResetEvent 将保持终止状态，直到一个正在等待的线程被释放，然后自动返回非终止状态。如果没有任何线程在等待，则状态将无限期地保持为终止状态。

可以通过将一个布尔值传递给构造函数来控制 AutoResetEvent 的初始状态，如果初始状态为终止状态，则为 true；否则为 false。

通俗的来讲只有等myResetEven.Set()成功运行后,myResetEven.WaitOne()才能够获得运行机会;Set是发信号，WaitOne是等待信号，只有发了信号，等待的才会执行。如果不发的话，WaitOne后面的程序就永远不会执行。