多線程Thread的用法

1.線程的用法

無參數的線程：　

        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread1 = new Thread(new ThreadStart(fun));
            thread1.Start();
        }

        private void fun()
        {
            int a = 0;
            for (int i = 0; i < 999999999; i++)
            {
                a = i;
            }
            MessageBox.Show(a.ToString());
        }     

帶參數的線程：

第一種方法：使用ParameterizedThreadStart。

 　　    private void button2_Click(object sender, EventArgs e)
        {
            Thread thread1 = new Thread(new ParameterizedThreadStart(fun1));
            //Thread thread1 = new Thread(fun1);//這樣寫也可以
            thread1.Start("123");

            List<string> list = new List<string> { "張三", "李四", "王五" };
            Thread thread2 = new Thread(new ParameterizedThreadStart(fun2));
            thread2.Start(list);
        }

　　     private void fun1(object obj)
        {
            //注意參數必須為object類型
            MessageBox.Show(obj.ToString());
        }

        private void fun2(object obj)
        {
            List<string> list = obj as List<string>;
            for (int i = 0; i < list.Count; i++)
            {
                MessageBox.Show(list[i]);
            }
        }

第二種方法：將線程執行的方法和參數都封裝到一個類里面。通過實例化該類，方法就可以調用屬性來實現間接的類型安全地傳遞參數。

        private void button3_Click(object sender, EventArgs e)
        {
            NewThread newThread = new NewThread("張三");//實例化對象
            Thread thread = new Thread(new ThreadStart(newThread.fun));
            thread.Start();

            List<string> list = new List<string> { "張三", "李四", "王五" };
            Thread thread2 = new Thread(new ParameterizedThreadStart(newThread.fun1));
            thread2.Start(list);
        }

    public class NewThread
    {
        private string name;
        public NewThread(string name)
        {
            this.name = name;
        }
        public void fun()
        {
            MessageBox.Show(string.Format("我的名字叫{0}", name));
        }
        public void fun1(object obj)
        {
            List<string> list = obj as List<string>;
            for (int i = 0; i < list.Count; i++)
            {
                MessageBox.Show(list[i]);
            }
        }
    }

2.IsBackground：獲取一個值，是否為后台線程。true為后台線程，false為前台線程，默認為前台線程。

前台線程和后台線程的區別：前台線程是應用程序必須運行完所有線程才可以退出。后台的則直接退出。

        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread1 = new Thread(new ThreadStart(fun));
            thread1.IsBackground = true;//后台線程
            thread1.Start();
        }
        private void fun()
        {
            int a = 0;
            for (int i = 0; i < 999999999; i++)
            {
                a = i;
            }
            MessageBox.Show(a.ToString());
        }

運行結果：當你關閉button1后立即關閉窗口，則整個程序退出，就不會彈窗了。

如果不設置thread1.IsBackground或者設置為false，當你關閉窗口后，應用程序應在執行，結果還會彈窗。

3.CheckForIllegalCrossThreadCalls和Invoke或BeginInvoke的用法。

這種異常的解決辦法：

第一種：CheckForIllegalCrossThreadCalls=false;不對它進行線程檢查(這種方法雖然簡單，但不提倡用)

 public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            TextBox.CheckForIllegalCrossThreadCalls = false;//是否對該控件進行線程檢查。
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread1 = new Thread(new ThreadStart(fun));
            thread1.IsBackground = true;
            thread1.Start();
        }
      
        private void fun()
        {
            for (int i = 0; i < 2000; i++)
            {
                int a = Convert.ToInt32(textBox1.Text);
                a++;
                textBox1.Text = a.ToString();
            }            
        }     
    }

第二種：Invoke和BeginInvoke

Control.Invoke 方法 (Delegate) :在擁有此控件的基礎窗口句柄的線程上執行指定的委托(是同步執行的，會阻塞當前線程，只允許單線程修改)。
Control.BeginInvoke 方法 (Delegate) :在創建控件的基礎句柄所在線程上異步執行指定委托(會啟用線程池，是異步的不會阻塞線程)。

        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread3 = new Thread(new ThreadStart(doWork));
            thread3.IsBackground = true;
            thread3.Start();
        }
        public delegate void MyInvoke();
        public void doWork()
        {
            MyInvoke callBack = new MyInvoke(fun3);
            //this.BeginInvoke(callBack);
            this.Invoke(callBack);
        }
        private void fun3()
        {
            for (int i = 0; i < 2000; i++)
            {
                int a = Convert.ToInt32(textBox1.Text);
                a++;
                textBox1.Text = a.ToString();
            }
        }

4.lock的用法

textBox1.Text的初始值為textBox1.Text="0"；
大家猜下當點擊Button時這個textBox1.Text的值會是多少呢？

        public Form1()
        {
            InitializeComponent();
            TextBox.CheckForIllegalCrossThreadCalls = false;//是否對蓋控件進行線程的調用。
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread1 = new Thread(new ThreadStart(fun));
            thread1.IsBackground = true;
            thread1.Start();

            Thread thread2 = new Thread(new ThreadStart(fun));
            thread2.IsBackground = true;
            thread2.Start();
        }

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

結果：

為什么會是一個隨機的數呢？而不是2000或者4000？

因為當你在點擊Button時，先開啟thread1然后再開啟thread2，但是都在執行着那個方法。在開啟thread2的時候，文本框內的值可能不是thread2線程上次的值。

例如：thread1在某次執行時，文本框里的值為1000，thread2上次執行的結果為999，它在這次執行時就有可能取thread1執行后的值1000來計算。這時文本框就為1001了。

所以整個下來，就會產生一個隨機的數字了。

解決辦法：

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

就是在方法中加上一個lock鎖。當thread1在執行時，不讓thread2執行這個循環。

最后的結果就是