BackgroundWorker 簡單使用教程多個線程的創建

本文轉載自查看原文 2013-03-17 13:58 6388 .Net 2.0

BackgroundWorker是一個非常不錯的線程控件，能避免界面假死，讓線程操作你想要做的事，它學習起來很簡單，但是能實現很強大的功能。發布這篇文章的目的是將最近學習到的共享出來，大家交流一下，當然我也是菜鳥，在這里你將學習到BackgroundWorker簡單使用，停止，暫停，繼續等操作，BackgroundWorker比起Thread和ThreadPool要簡單太多，為了更方便在實際應用中使用，我使用的是winform，沒有使用控制台程序。

在UI界面里拖動一個button和richTextBox到界面。

我會從最簡單的開始，只有最簡單的代碼才會讓人有繼續學下去的欲望，下列代碼可以將1到999打印到richTextBox1控件上。

 1 private void button1_Click(object sender, EventArgs e)
 2 {
 3     //創建一個BackgroundWorker線程
 4     BackgroundWorker bw = new BackgroundWorker();
 5     //創建一個DoWork事件，指定bw_DoWork方法去做事
 6     bw.DoWork += new DoWorkEventHandler(bw_DoWork);
 7     //開始執行
 8     bw.RunWorkerAsync();
 9 }
10 
11 void bw_DoWork(object sender, DoWorkEventArgs e)
12 {
13     for (int i = 0; i < 1000; i++)
14     {
15         this.richTextBox1.Text += i + Environment.NewLine;
16     }
17 }

但是很不幸，以上代碼會報錯，報錯信息：線程間操作無效: 從不是創建控件“richTextBox1”的線程訪問它。

那么我們繼續改造代碼，讓數字顯示在richTextBox1控件上，並且讓richTextBox1焦點處於最低端。

 1 private void button1_Click(object sender, EventArgs e)
 2 {
 3     //創建一個BackgroundWorker線程
 4     BackgroundWorker bw = new BackgroundWorker();
 5     //創建一個DoWork事件，指定bw_DoWork方法去做事
 6     bw.DoWork += new DoWorkEventHandler(bw_DoWork);
 7     //開始執行
 8     bw.RunWorkerAsync();
 9 }
10 
11 void bw_DoWork(object sender, DoWorkEventArgs e)
12 {
13     for (int i = 0; i < 1000; i++)
14     {
15         this.Invoke((MethodInvoker)delegate
16         {
17             this.richTextBox1.Text += i + Environment.NewLine;
18         });
19     }
20 }
21 
22 private void richTextBox1_TextChanged(object sender, EventArgs e)
23 {
24     RichTextBox textbox = (RichTextBox)sender;
25 
26     textbox.SelectionStart = textbox.Text.Length;
27     textbox.ScrollToCaret();
28 }

上面是BackgroundWorker一個最簡單的例子，沒有多余復雜的代碼，這就是BackgroundWorker，下面我們加入停止按鈕，讓線程停下來。

再拖動一個button控件到界面，讓線程停止我們先要改造一下代碼，讓button事件也能控制到BackgroundWorker線程。

 1 BackgroundWorker bw = null;
 2 
 3 private void button1_Click(object sender, EventArgs e)
 4 {
 5     //創建一個BackgroundWorker線程
 6     bw = new BackgroundWorker();
 7     //指定可以讓線程停止
 8     bw.WorkerSupportsCancellation = true;
 9     //創建一個DoWork事件，指定bw_DoWork方法去做事
10     bw.DoWork += new DoWorkEventHandler(bw_DoWork);
11     //開始執行
12     bw.RunWorkerAsync();
13 }
14 
15 private void button2_Click(object sender, EventArgs e)
16 {
17     //停止線程
18     bw.CancelAsync();
19 }
20 
21 void bw_DoWork(object sender, DoWorkEventArgs e)
22 {
23     for (int i = 0; i < 1000; i++)
24     {
25         //獲取當前線程是否得到停止的指令
26         if (bw.CancellationPending)
27         {
28             e.Cancel = true;
29             return;
30         }
31 
32         this.Invoke((MethodInvoker)delegate
33         {
34             this.richTextBox1.Text += i + Environment.NewLine;
35         });
36     }
37 }

為了避免代碼的復雜化，上面代碼我沒有做更多的體驗修改，比如點擊開始的按鈕，開始的按鈕應該為不可用狀態，點擊停止按鈕后停止按鈕不可用狀態，激活開始按鈕。

下面我們將繼續升級，如何來獲知線程是否已經執行完成或者線程已經停止了呢

 1 BackgroundWorker bw = null;
 2 
 3 private void button1_Click(object sender, EventArgs e)
 4 {
 5     bw = new BackgroundWorker();
 6     bw.WorkerSupportsCancellation = true;
 7     bw.DoWork += new DoWorkEventHandler(bw_DoWork);
 8     //線程完成或者停止發生的事件
 9     bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
10 
11     bw.RunWorkerAsync();
12 }
13 
14 private void button2_Click(object sender, EventArgs e)
15 {
16     bw.CancelAsync();
17 }
18 
19 void bw_DoWork(object sender, DoWorkEventArgs e)
20 {
21     for (int i = 0; i < 1000; i++)
22     {
23         if (bw.CancellationPending)
24         {
25             e.Cancel = true;
26             return;
27         }
28 
29         this.Invoke((MethodInvoker)delegate
30         {
31             this.richTextBox1.Text += i + Environment.NewLine;
32         });
33     }
34 }
35 
36 void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
37 {
38     if (e.Cancelled)
39     {
40         this.richTextBox1.Text += "線程已經停止";
41     }
42     else
43     {
44         this.richTextBox1.Text += "線程已經完成";
45     }
46 }

到現在為止你可以自己去用BackgroundWorker創建一個線程了，你已經了解它了，當然BackgroundWorker還有一個ReportProgress滾動條事件，可以顯示進度，我暫且認為它是多余的，因為大部分進度都可以通過bw_DoWork來控制實現。下面我們繼續完善BackgroundWorker，加入暫停和繼續功能。

再拖動一個button控件到界面，BackgroundWorker的暫停和繼續我們使用ManualResetEvent。

 1 BackgroundWorker bw = null;
 2 //創建ManualResetEvent
 3 ManualResetEvent mr = new ManualResetEvent(true);  
 4 
 5 private void button1_Click(object sender, EventArgs e)
 6 {
 7     bw = new BackgroundWorker();
 8     bw.WorkerSupportsCancellation = true;
 9     bw.DoWork += new DoWorkEventHandler(bw_DoWork);
10     bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
11 
12     bw.RunWorkerAsync();
13 }
14 
15 private void button2_Click(object sender, EventArgs e)
16 {
17     bw.CancelAsync();
18 }
19 
20 private void button3_Click(object sender, EventArgs e)
21 {
22     Button b = (Button)sender;
23     if (b.Text == "暫停")   
24     {   
25         mr.Reset();
26         b.Text = "繼續";   
27     }   
28     else  
29     {   
30         mr.Set();   
31         b.Text = "暫停";   
32     }  
33 
34 }
35 
36 void bw_DoWork(object sender, DoWorkEventArgs e)
37 {
38     for (int i = 0; i < 1000; i++)
39     {
40         if (bw.CancellationPending)
41         {
42             e.Cancel = true;
43             return;
44         }
45 
46         this.Invoke((MethodInvoker)delegate
47         {
48             this.richTextBox1.Text += i + Environment.NewLine;
49         });
50 
51         //接受指令
52         mr.WaitOne();
53     }
54 }
55 
56 void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
57 {
58     if (e.Cancelled)
59     {
60         this.richTextBox1.Text += "線程已經停止";
61     }
62     else
63     {
64         this.richTextBox1.Text += "線程已經完成";
65     }
66 }

到目前為止BackgroundWorker的大部分功能都實現了，上面的代碼在很多博客中都能找到，都是只執行了一個后台線程。如果我們有1千個耗時的任務，那么一個線程遠遠不夠，我們需要創建多條線程，讓他分段執行，比如創建10個線程，把1千個任務分成不同的等分讓10個線程分別去執行。

我們使用list泛型 List<BackgroundWorker>，然后使用bw.RunWorkerAsync(i) 傳遞參數到bw_DoWork里，在bw_DoWork里使用e.Argument接受參數。

 1 List<BackgroundWorker> bws = new List<BackgroundWorker>();
 2 int t = 10;
 3 
 4 private void button1_Click(object sender, EventArgs e)
 5 {
 6     for (int i = 0; i < t; i++)
 7     {
 8         BackgroundWorker bw = new BackgroundWorker();
 9         bw.DoWork += new DoWorkEventHandler(bw_DoWork);
10         bws.Add(bw);
11 
12         bw.RunWorkerAsync(i);
13     }
14 }
15 
16 void bw_DoWork(object sender, DoWorkEventArgs e)
17 {
18     int j = Convert.ToInt32(e.Argument); 
19     for (int i = j; i < 1000; i = i + t) 
20     {
21         if (((BackgroundWorker)sender).CancellationPending)  
22         {
23             e.Cancel = true;
24             return;
25         }
26 
27         string item = String.Format("線程{0}正在操作數據{1}", j + 1, i);
28 
29         this.Invoke((MethodInvoker)delegate
30         {
31             this.richTextBox1.Text += item + Environment.NewLine;
32         });
33 
34         //Thread.Sleep(200);
35     }
36 }

由於上面代碼不是耗時操作，又開啟線程10個，操作過快，造成界面假死狀態，可以使用Sleep讓線程休眠。

我們繼續完善代碼，加入停止操作，加入完成后和停止的事件，由於是多線程，判斷是線程操作是否完成，我們用bws.Remove(sender as BackgroundWorker); 方法刪除線程，然后使用bws.Count == 0來判斷是否操作完成。

 1 List<BackgroundWorker> bws = new List<BackgroundWorker>();
 2 int t = 10;
 3 
 4 private void button1_Click(object sender, EventArgs e)
 5 {
 6     for (int i = 0; i < t; i++)
 7     {
 8         BackgroundWorker bw = new BackgroundWorker();
 9         bw.DoWork += new DoWorkEventHandler(bw_DoWork);
10         bw.WorkerSupportsCancellation = true;
11         bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
12         bws.Add(bw);
13 
14         bw.RunWorkerAsync(i);
15     }
16 }
17 
18 private void button2_Click(object sender, EventArgs e)
19 {
20     for (int i = 0; i < t; i++)
21     {
22         bws[i].CancelAsync();
23     }
24 }
25 
26 void bw_DoWork(object sender, DoWorkEventArgs e)
27 {
28     int j = Convert.ToInt32(e.Argument); 
29     for (int i = j; i < 1000; i = i + t) 
30     {
31         if (((BackgroundWorker)sender).CancellationPending)  
32         {
33             e.Cancel = true;
34             return;
35         }
36 
37         string item = String.Format("線程{0}正在操作數據{1}", j + 1, i);
38 
39         this.Invoke((MethodInvoker)delegate
40         {
41             this.richTextBox1.Text += item + Environment.NewLine;
42         });
43 
44         Thread.Sleep(200);
45     }
46 }
47 
48 void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
49 {
50     bws.Remove(sender as BackgroundWorker);
51     if (bws.Count == 0)
52     {
53         if (e.Cancelled)
54         {
55             this.richTextBox1.Text += "線程已經停止";
56         }
57         else
58         {
59             this.richTextBox1.Text += "線程已經完成";
60         }
61     }
62 }

上面代碼中的停止不是能立即停止，這個就和開車一樣，開的越快，剎車的后拖行的距離越長，同理，開啟的線程的越多，完全暫停需要的時間越長，不知我說的是否正確。另外我也想問一下是否能真正的全部線程停止，點停止后全部線程立即停止。

下面我們繼續加入暫停和繼續的功能，一樣的道理，我們使用List<ManualResetEvent>。

 1 List<BackgroundWorker> bws = new List<BackgroundWorker>();
 2 List<ManualResetEvent> mrs = new List<ManualResetEvent>();  
 3 int t = 10;
 4 
 5 private void button1_Click(object sender, EventArgs e)
 6 {
 7     for (int i = 0; i < t; i++)
 8     {
 9         BackgroundWorker bw = new BackgroundWorker();
10         bw.DoWork += new DoWorkEventHandler(bw_DoWork);
11         bw.WorkerSupportsCancellation = true;
12         bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
13         bws.Add(bw);
14 
15         bw.RunWorkerAsync(i);
16 
17         mrs.Add(new ManualResetEvent(true));
18     }
19 }
20 
21 private void button2_Click(object sender, EventArgs e)
22 {
23     for (int i = 0; i < t; i++)
24     {
25         bws[i].CancelAsync();
26     }
27 }
28 
29 private void button3_Click(object sender, EventArgs e)
30 {
31     Button b = (Button)sender;   
32     if (b.Text == "暫停")   
33     {   
34         for (int i = 0; i < mrs.Count; i++)   
35         {   
36             mrs[i].Reset();   
37         }   
38         b.Text = "繼續";   
39     }   
40     else  
41     {   
42         for (int i = 0; i < mrs.Count; i++)   
43         {   
44             mrs[i].Set();   
45         }   
46         b.Text = "暫停";   
47     }   
48 }
49 
50 void bw_DoWork(object sender, DoWorkEventArgs e)
51 {
52     int j = Convert.ToInt32(e.Argument); 
53     for (int i = j; i < 1000; i = i + t) 
54     {
55         if (((BackgroundWorker)sender).CancellationPending)  
56         {
57             e.Cancel = true;
58             return;
59         }
60 
61         string item = String.Format("線程{0}正在操作數據{1}", j + 1, i);
62 
63         this.Invoke((MethodInvoker)delegate
64         {
65             this.richTextBox1.Text += item + Environment.NewLine;
66         });
67 
68         Thread.Sleep(200);
69         mrs[j].WaitOne();  
70     }
71 }
72 
73 void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
74 {
75     bws.Remove(sender as BackgroundWorker);
76     if (bws.Count == 0)
77     {
78         if (e.Cancelled)
79         {
80             this.richTextBox1.Text += "線程已經停止";
81         }
82         else
83         {
84             this.richTextBox1.Text += "線程已經完成";
85         }
86     }
87 }

至此，所有的代碼都奉上了，多個線程操作會帶來很多意向不到的麻煩，比如多個線程同時把數據寫入一個文件，多線程更新datatable等，會讓軟件莫名其妙的自動退出，.net2.0里還沒有絕對線程安全的數據集，很多大佬都說用lock，但我對lock也是一知半解，還請大家賜教賜教，如上有什么說的不對，也請大家多多指點。

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 1、簡單的BackGroundWorker多線程時時刷新UI界面，並顯示進度使用后台線程BackgroundWorker處理任務的總結 Linux 循環創建多個線程 WPF線程(Step2)——BackgroundWorker C# BackgroundWorker的使用 BackgroundWorker控件使用（一） winform BackgroundWorker的使用 Linux：回收循環創建的多個線程 C# BackgroundWorker使用總結 BackgroundWorker簡單實用(簡便的異步操作)

BackgroundWorker 簡單使用教程 多個線程的創建

免責聲明！

BackgroundWorker 簡單使用教程多個線程的創建