原文:BackgroundWorker 简单使用教程 多个线程的创建

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 = ; i < ; 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 = ; i < ; 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 = ; i < ; 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 = ; i < ; 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 = ; i < ; 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 = ;
  3.  
  4.  private void button1_Click(object sender, EventArgs e)
  5.  {
  6.      for (int i = ; 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 < ; 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 + , 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 = ;
  3.  
  4.  private void button1_Click(object sender, EventArgs e)
  5.  {
  6.      for (int i = ; 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 = ; 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 < ; 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 + , i);
  38.  
  39.          this.Invoke((MethodInvoker)delegate
  40.          {
  41.              this.richTextBox1.Text += item + Environment.NewLine;
  42.          });
  43.  
  44.          Thread.Sleep();
  45.      }
  46.  }
  47.  
  48.  void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
  49.  {
  50.      bws.Remove(sender as BackgroundWorker);
  51.      if (bws.Count == )
  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 = ;
  4.  
  5.  private void button1_Click(object sender, EventArgs e)
  6.  {
  7.      for (int i = ; 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 = ; 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 = ; i < mrs.Count; i++)
  35.          {
  36.              mrs[i].Reset();
  37.          }
  38.          b.Text = "继续";
  39.      }
  40.      else
  41.      {
  42.          for (int i = ; 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 < ; 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 + , i);
  62.  
  63.          this.Invoke((MethodInvoker)delegate
  64.          {
  65.              this.richTextBox1.Text += item + Environment.NewLine;
  66.          });
  67.  
  68.          Thread.Sleep();
  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 == )
  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也是一知半解，还请大家赐教赐教，如上有什么说的不对，也请大家多多指点。

BackgroundWorker 简单使用教程 多个线程的创建的更多相关文章

  1. OpenMP的简单使用教程

    转自:http://binglispace.com/2015/01/09/openmp-intro/ OpenMP的简单使用教程 今天有幸参加了一个XSEDE OpenMP的workshop讲座,真是 ...

  2. Jvisualvm简单使用教程

    本博客介绍一下jvisualvm的简单使用教程,jvisualvm功能还是挺多的,不过本博客之简单介绍一下 1.拿线程快照信息 在jdk安装目录找到jvisualvm.exe,${JDK_HOME}\ ...

  3. 程序员，一起玩转GitHub版本控制，超简单入门教程 干货2

    本GitHub教程旨在能够帮助大家快速入门学习使用GitHub,进行版本控制.帮助大家摆脱命令行工具,简单快速的使用GitHub. 做全栈攻城狮-写代码也要读书,爱全栈,更爱生活. 更多原创教程请关注 ...

  4. knockout.js简单实用教程1

    第一次接触knockout是在一年多之前吧.当时是接手了一个别人的项目,在项目中有用到knockout来进行数据的绑定.也就开始学习起来knockout.在之后的项目中也多次用到了这个.在第一次开始学 ...

  5. knockout简单实用教程3

    在之前的文章里面介绍了一些KO的基本用法.包括基本的绑定方式,基本的ko的绑定语法包括text绑定,html绑定等等(如有不明请参照上两篇文章),下面呢介绍一下关于ko的其他方面的知识.包括比较特殊绑 ...

  6. GitHub这么火，程序员你不学学吗？ 超简单入门教程 【转载】

    本GitHub教程旨在能够帮助大家快速入门学习使用GitHub. 本文章由做全栈攻城狮-写代码也要读书,爱全栈,更爱生活.原创.如有转载,请注明出处. GitHub是什么? GitHub首先是个分布式 ...

  7. (6)简单说说java中的线程

    先甩出来两种创建线程的方法: private static int count = 100; public static void main(String[] args) { // 用继承Thread ...

  8. 【并发编程】一个最简单的Java程序有多少线程？

    一个最简单的Java程序有多少线程? 通过下面程序可以计算出当前程序的线程总数. import java.lang.management.ManagementFactory; import java. ...

  9. sea.js简单使用教程

    sea.js简单使用教程 下载sea.js, 并引入 官网: http://seajs.org/ github : https://github.com/seajs/seajs 将sea.js导入项目 ...

随机推荐

  1. MFC获取各个窗体(体)之间的指针(对象)

    MFC在非常多的对话框操作中,我们常常要用到在一个对话框中调用还有一个对话框的函数或变量.能够用例如以下方法来解决.    HWND hWnd=::FindWindow(NULL,_T("S ...

  2. 十年磨一剑 Delphi再写传奇（不争辩，不解释，十年坚持不懈的努力）

    新年伊始,英巴卡迪诺公司(Embarcadero)就在其官网发布了“激动人心的RAD Studio2018年发展规划”公告(见上图).公告中指出,将在于2018年发布10.3.X新版本,新版本兼容Ex ...

  3. Undefined symbols for architecture i386: "_OBJC_CLASS_$_KKGridView", referenced from:

    Undefined symbols for architecture i386: "_OBJC_CLASS_$_KKGridView", referenced from:

  4. 【BZOJ 1016】[JSOI2008]最小生成树计数(搜索+克鲁斯卡尔)

    [题目链接]:http://www.lydsy.com/JudgeOnline/problem.php?id=1016 [题意] [题解] /* 两个最小生成树T和T'; 它们各个边权的边的数目肯定是 ...

  5. 【BZOJ 1034】[ZJOI2008]泡泡堂BNB

    [题目链接]:http://www.lydsy.com/JudgeOnline/problem.php?id=1034 [题意] [题解] 如果己方最小的大于对方最小的(严格大于) 或己方最大的大于对 ...

  6. Python采用struct处理二进制

    有时需要使用python二进制数据,实例,件.socket操作时.这时候.能够使用python的struct模块来完毕.能够用 struct来处理c语言中的结构体. struct模块中最重要的三个函数 ...

  7. matlab 高级函数 —— circshift、squeeze

    circshift:顾名思义,循环移动,循环的意义在于,移出的数据不丢失,而是来到队列的首部位置,也即其实是将原始序列视为一种圆环. 1. 基本用法 默认为右移. Y = circshift(A,K) ...

  8. Apache2.4.25 VirtualHost rewrite_module

    LoadModule rewrite_module libexec/apache2/mod_rewrite.so Include /private/etc/apache2/extra/httpd-vh ...

  9. less - 循环 loop

    .avatar-loop(@n, @i:1, @level) when (@i <= @n) { &:nth-child(@{level}) .item.item-@{i} { .ava ...

  10. 学习Hadoop和Spark的好的资源

    1. 官网http://spark.apache.org 有各种资源链接: 2. 总结得很好的个人博客[从零开始学Hadoop系列]1)初识http://blog.csdn.net/u01016816 ...