线程

线程

线程应用场景:

(1):希望获得更多操作系统资源尽快处理我们的业务,缩短处理的时间

(2) 如果一个非常复杂的操作.需要占用非常长的时间,而WinFrom又不允许阻塞UI线程

后台线程

创建线程

  private void button2_Click(object sender, EventArgs e)
        {
            //创建一个委托指向其中一个方法
            ThreadStart threadStart = new ThreadStart(StartCaul);
            //创建线程
            Thread myThread = new Thread(threadStart);//可以直接放方法名进去 StartCaul
            //开启线程
            myThread.Start();
            //设置线程的优先级
            myThread.Priority = ThreadPriority.Normal;//建议操作系统将创建的线程优先级设置为最高。
            //可以给线程起个名字
            myThread.Name = "myThreadBB";
            //终止线程
            myThread.Abort();
            //阻塞主线程执行
            myThread.Join(1000);
            //设置后台线程
            myThread.IsBackground = true;

        }

控制线程结束

   bool isStop = false;
        private void StartCaul()
        {
            int a = 0;
            for (int i = 0; i < 600000000; i++)
            {
                if (!isStop)
                {
                    a = i;
                }
                else
                {
                  
                }
            }
            //MessageBox.Show(a.ToString());
            this.textBox1.Text = a.ToString();
        }

微软提供跨线程检测 不建议把他用一下方法取消

TextBox.CheckForIllegalCrossThreadCalls = false;

跨线程访问

 /// <summary>
        /// 完美的跨线程访问   要访问主线程创建的TextBox 需设置跨线程访问
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button4_Click(object sender, EventArgs e)
        {
            //创建一个线程
            Thread thread1 = new Thread(ShowResult);
            //设置为后台线程
            thread1.IsBackground = true;
            thread1.Start();
        }
        private void ShowResult()
        {
            int a = 0;
            for (int i = 0; i < 600000000; i++)
            {
               
                a = i;
              
            }
                 //现在就是对文本框进行跨线程访问 返回是true
            if (this.textBox1.InvokeRequired)//是否要对文本框进行跨线程访问。
            {
                //Invoke：去找创建TextBox的线程（主线程（UI线程）），由主线程完成委托方法的调用。
                //后面2个参数给方法传值
                //泛型约束<TextBox, string>
                this.textBox1.Invoke(new Action<TextBox, string>(ShowTextBoxValue), this.textBox1, a.ToString());//
            }
            else
            {
                this.textBox1.Text = a.ToString();
            }
        }
        //给文本框赋值函数 不需要返回值
        private void ShowTextBoxValue(TextBox txt,string value)
        {
            txt.Text = value;

        }

线程执行带参数的方法

 private void button3_Click(object sender, EventArgs e)
        {
            //创建一个List集合
            List<int> list = new List<int>() {1,2,3,4,5 };
            //传一个方法
            ParameterizedThreadStart parThreadStart = new ParameterizedThreadStart(Show);
            Thread thread1 = new Thread(parThreadStart);
            //标记为后台线程
            thread1.IsBackground = true;
            //Start方法有2个参数 向方法传递参数
            thread1.Start(list);
        }
        private void Show(object obj)
        {
            //遍历list集合输出
            List<int> list = obj as List<int>;
            foreach (int i in list)
            {
                MessageBox.Show(i.ToString());
            }
        }

多线程同步

当多个线程访问同一资源时要加锁，多用户并发问题.加锁可以解决多线程访问同一资源问题,但是它带来的问题比较慢

     //开启2个线程调同一个方法 当多个线程访问同一资源时要加锁

        private void button5_Click(object sender, EventArgs e)
        {
          //  this.textBox1.Text = "safasdfd";
            Thread thread1 = new Thread(AddSum);
            thread1.IsBackground = true;
            thread1.Start();

            Thread thread2 = new Thread(AddSum);
            thread2.IsBackground = true;
            thread2.Start();
        }
        //锁 
        private static readonly object obj = new object();

        private void AddSum()
        {
            lock (obj)  
            {

                for (int i = 0; i < 2000; i++)
                {
                    int a = Convert.ToInt32(this.textBox1.Text);
                    a++;
                    this.textBox1.Text = a.ToString();
                }
            }
           
        }

浏览器对服务器发送请求，等于开启了一个线程，线程本身是消耗资源的，一台web服务器挺不住太多线程,CPU来回切换消耗资源

lock 是一个语法糖  实际写法Monitor.Enter(obj)

线程池

什么时候用线程池? 什么时候手动创建线程?
1,能用线程池的就用线程池

2.我们想手动关闭线程的话那么必须手动创建  Abort() Join()

3.我们需要对线程池的线程的优先级做设置的情景下,只能使用手动创建线程

4.如果执行的线程执行时间特别长,建议手动创建线程.

线程池:提高了线程的利用率,非常适合工作任务比较小,而且又需要使用单独的线程来解决的问题.

线程切换消耗资源,cpu在切换线程的时候,需要把当前线程执行的状态保持到寄存器里面去.

线程创建非常消耗资源.线程创建非常慢,占用大量的内存空间,每个线程最少1M内存开销.

  Stopwatch  sw =new Stopwatch();
            sw.Start();
            for (int i = 0; i < 1000; i++)
            {
               new Thread(() =>
                 {
                      int i2 = 1 + 1;
                     
                    }).Start();
           }
           sw.Stop();
           Console.WriteLine(sw.Elapsed.TotalMilliseconds);

            //重新开始计时
          sw.Reset();
           sw.Restart();
           for (int i = 0; i < 1000; i++)
          {
               //从线程池取出一个线程
              ThreadPool.QueueUserWorkItem(new WaitCallback(PoolCallBack), "sssss"+i);
               //ThreadPool.GetMaxThreads
           }
           sw.Stop();
           Console.WriteLine(sw.Elapsed.TotalMilliseconds);

           Console.ReadKey();
          
        }
        private static void PoolCallBack(object state)
        {
            int i = 1 + 1;

        }