Thread t = new Thread(()=> {

                for (int i = 0; i < 100; i++)
                {
                    Console.WriteLine($"我是子线程({i})~~~~");
                }

            });// 参数 ThreadStart 是一个委托类型的。凡是委托，我们都可以使用lambda 表达式代替
            t.Start();//Start 通过Start开启一个线程
            for (int i = 0; i < 100; i++)
            {
                Console.WriteLine($"我是主线程【{i}】");
            }

       public void WriteJob(string name) {
            Console.WriteLine("********************** "+ name + " Start【" + Thread.CurrentThread.ManagedThreadId + "】等待............... ***");
            Stopwatch watch = new Stopwatch();
            watch.Start();
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(32);
                Console.WriteLine($"学生:{name}在做第{i+1}题作业");
            }
            watch.Stop();
            Console.WriteLine("********************** " + name + " End【" + Thread.CurrentThread.ManagedThreadId + "】 用时"+ watch.ElapsedMilliseconds + "毫秒............... ***");
        }

 /// <summary>
        /// 线程等待
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            Console.WriteLine("**********************button2_Click Start【" + Thread.CurrentThread.ManagedThreadId + "】**********************************************");

            List<Thread> threadList = new List<Thread>();
            for (int i = 0; i < 5; i++)
            {
                string studentName = "甲" + i + "同学";
                Thread thread = new Thread(() => WriteJob(studentName));
                Console.WriteLine($"{studentName}开始写作业");
                thread.Start();
                threadList.Add(thread);
            }

            //无损耗阻塞主线程
            //foreach (var thread in threadList)
            //{
            //    thread.Join();//表示把thread线程任务join到当前线程，也就是当前线程等着thread任务完成
            //}
            //带返回，有损耗阻塞主线程
            while (threadList.Count(t => t.ThreadState != System.Threading.ThreadState.Stopped) > 0)
            {
                Thread.Sleep(100);
                Console.WriteLine("请等待....");
            }
           
            Console.WriteLine("**********************button2_Click end【" + Thread.CurrentThread.ManagedThreadId + "】**********************************************");
        }

 #region 异步回调回顾
            {
                //回调
                AsyncCallback callBack = param =>
                {
                    Console.WriteLine("当前状态:"+param.AsyncState);
                    Console.WriteLine("你睡吧，我去吃好吃的去了");
                };
                Func<string, int> func = t => {
                    
                    Console.WriteLine(t);
                    Thread.Sleep(5000);
                    Console.WriteLine("等等吧，我在睡一会");
                    return DateTime.Now.Millisecond;//返回当前毫秒数
                };
                ///第一个参数是我们自定义的参数，第二个参数是我们回调的参数，第三个参数是状态参数
               IAsyncResult iAsyncResult= func.BeginInvoke("张四火，起床吧", callBack, "runState");
               int second= func.EndInvoke(iAsyncResult);
                Console.WriteLine("当前毫秒数："+second);
            }
            {
                //回调
                AsyncCallback callBack = param =>
                {
                    Console.WriteLine("当前状态:" + param.AsyncState);
                    Console.WriteLine("妈妈说：孩子太小，睡会吧");
                };
              // 异步 
                Action<string> act = t =>
                {
                    Console.WriteLine(t);
                    Thread.Sleep(5000);
                    Console.WriteLine("等等吧，我在睡一会");
                   
                };
                IAsyncResult iAsyncResult = act.BeginInvoke("梓烨，起床吧", callBack, "runState");
                 act.EndInvoke(iAsyncResult);
            }
            #endregion

   #region 回调封装
        /// <summary>
        /// 回调封装 无返回值
        /// </summary>
        /// <param name="start"></param>
        /// <param name="callback">回调</param>
        private void ThreadWithCallback(ThreadStart start, Action callback)
        {
            Thread thread = new Thread(() =>
            {
                start.Invoke();
                callback.Invoke();
            });
            thread.Start();
        }

        /// <summary>
        /// 有返回值封装（请根据本案例自行封装回调）
        /// </summary>
        /// <typeparam name="T">返回值类型</typeparam>
        /// <param name="func">需要子线程执行的方法</param>
        /// <returns></returns>
        private Func<T> ThreadWithReturn<T>(Func<T> func)
        {
            T t = default(T);//初始化一个泛型
            ThreadStart newStart = () =>
            {
                t = func.Invoke();

            };
            Thread thread = new Thread(newStart);
            thread.Start();

            return new Func<T>(() =>
            {
                thread.Join();
                return t;
            });
        }
        #endregion 

   #region 多线程回调封装调用
            {
                //无返回
                ThreadWithCallback(()=>{
                    Console.WriteLine("梓烨，起床吧");
                    Thread.Sleep(5000);
                    Console.WriteLine("等等吧，我在睡一会");
                },()=> {
                    Console.WriteLine("妈妈说：梓烨太小，睡会吧");
                });
            }
            {
                //有返回
              int secound=  ThreadWithReturn<int>(()=>{
                    Console.WriteLine("张四火，起床吧");
                    Thread.Sleep(5000);
                    Console.WriteLine("等等吧，我在睡一会");
                    return DateTime.Now.Millisecond;//返回当前毫秒数
                }).Invoke();
                Console.WriteLine(secound);
            }
            #endregion

 static void Main(string[] args)
        {
            BookShop book = new BookShop();
            //创建两个线程同时访问Sale方法
            Thread t1 = new Thread(new ThreadStart(book.Sale));//因为使用的同一个引用，所以书店库存量始终是一个地址的引用
            Thread t2 = new Thread(new ThreadStart(book.Sale));
            //启动线程
            t1.Start();
            t2.Start();
            Console.ReadKey();
        }

        class BookShop
        {
            public int num = 1;//库存量
            public void Sale()
            {
                int tmp = num;
                if (tmp > 0)//判断是否有书，如果有就可以卖
                {
                    Thread.Sleep(1000);
                    num -= 1;
                    Console.WriteLine("售出一本图书，还剩余{0}本", num);
                }
                else
                {
                    Console.WriteLine("没有了");
                }
            }
        }

 class BookShop
        {
            public int num = 1;//库存量
            public void Sale()
            {
                // 使用lock关键字解决线程同步问题。锁住当前对象
                lock (this)
                {
                    int tmp = num;
                    if (tmp > 0)//判断是否有书，如果有就可以卖
                    {
                        Thread.Sleep(1000);
                        num -= 1;
                        Console.WriteLine("售出一本图书，还剩余{0}本", num);
                    }
                    else
                    {
                        Console.WriteLine("没有了");
                    }
                }
                
            }
        }

 System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;

   private void button1_Click(object sender, EventArgs e)
        {
            Action<int> act = t=> { this.textBox1.Text = t.ToString(); };
            //创建一个线程去执行这个方法:创建的线程默认是前台线程
            Thread thread = new Thread(()=> {
                for (int i = 0; i < 100; i++)
                {
                    Thread.Sleep(100);
                    this.textBox1.Invoke(act, i);
                    // this.textBox1.Invoke(t => { this.textBox1.Text = t.ToString(); }, i);这里不允许使用 lambda 表达式，因为里面传递的是一个委托类型，不是委托
                }
            });
            //Start方法标记这个线程就绪了，可以随时被执行，具体什么时候执行这个线程，由CPU决定
            //将线程设置为后台线程
            thread.IsBackground = true;
            thread.Start();
        }

 int workerThreads = 0;
            int ioThreads = 0;
            ThreadPool.GetMaxThreads(out workerThreads, out ioThreads);
            Console.WriteLine(String.Format("可创建最大线程数: {0};    最大 I/O 线程: {1}", workerThreads, ioThreads));

            ThreadPool.GetMinThreads(out workerThreads, out ioThreads);
            Console.WriteLine(String.Format("最小线程数: {0};    最小 I/O 线程: {1}", workerThreads, ioThreads));

            ThreadPool.GetAvailableThreads(out workerThreads, out