可以编写能同时执行多个任务的应用程序。此能力（称为“多线程处理”或“自由线程处理”）是设计处理器密集型且要求用户输入的组件的强大方法。计算工资表信息的组件就是一个可能利用多线程处理的组件示例。该组件可以在一个线程上处理用户输入到数据库的数据，而在另一个线程上执行频繁使用处理器的工资表计算。通过在不同的线程上运行这些进程，用户不必等到计算机完成计算，就可以输入其他数据。在本演练中，将创建一个简单的多线程组件，该组件可以同时执行若干个复杂计算。
应用程序将包括单个窗体和一个组件。用户将输入值并指示该组件开始计算。然后，窗体将接收来自该组件的值，将其显示在标签控件中。该组件将执行频繁使用处理器的计算，并在完成后通知窗体。您将在组件中创建公共变量，用以保存从用户界面收到的值。同时，您还将在组件中实现一些方法，根据这些变量的值执行计算。
注意 尽管对于计算值的方法来说，函数通常更为可取，但不能在线程之间传递参数，也不能返回值。有很多向线程提供值和从线程接收值的简单方法。在本演示中，将通过更新公共变量将值返回到用户界面，当线程执行完毕后，使用事件来通知主程序。
创建窗体
该窗体将用作应用程序的主用户界面。
| 控件 | 名称 | 文本 |
|---|---|---|
| Label1 | lblFactorial1 | （空白） |
| Label2 | lblFactorial2 | （空白） |
| Label3 | lblAddTwo | （空白） |
| Label4 | lblRunLoops | （空白） |
| Label5 | lblTotalCalculations | （空白） |
| Button1 | btnFactorial1 | Factorial |
| Button2 | btnFactorial2 | Factorial - 1 |
| Button3 | btnAddTwo | Add Two |
| Button4 | btnRunLoops | Run a Loop |
| Textbox1 | txtValue | （空白） |
创建 Calculator 组件
向 Calculator 组件添加公共变量
变量 varTotalCalculations 将保留该组件执行的计算总数的累计值，而其他变量将接收来自窗体的值。
public int varAddTwo; public int varFact1; public int varFact2; public int varLoopValue; public double varTotalCalculations = 0;
向 Calculator 组件添加方法和事件
注意 尽管您将声明 4 个事件，但由于其中的两个事件将具有相同的签名，因此只需要创建 3 个委托。
紧接着上一步输入的变量声明的下方，键入下列代码：
// This delegate will be invoked with two of your events. public delegate void FactorialCompleteHandler(double Factorial, double TotalCalculations); public delegate void AddTwoCompleteHandler(int Result, double TotalCalculations); public delegate void LoopCompleteHandler(double TotalCalculations, int Counter);
public event FactorialCompleteHandler FactorialComplete; public event FactorialCompleteHandler FactorialMinusOneComplete; public event AddTwoCompleteHandler AddTwoComplete; public event LoopCompleteHandler LoopComplete;
// This method will calculate the value of a number minus 1 factorial
// (varFact2-1!).
public void FactorialMinusOne()
{
double varTotalAsOfNow = 0;
double varResult = 1;
// Performs a factorial calculation on varFact2 - 1.
for (int varX = 1; varX <= varFact2 - 1; varX++)
{
varResult *= varX;
// Increments varTotalCalculations and keeps track of the current
// total as of this instant.
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
}
// Signals that the method has completed, and communicates the
// result and a value of total calculations performed up to this
// point.
FactorialMinusOneComplete(varResult, varTotalAsOfNow);
}
// This method will calculate the value of a number factorial.
// (varFact1!)
public void Factorial()
{
double varResult = 1;
double varTotalAsOfNow = 0;
for (int varX = 1; varX <= varFact1; varX++)
{
varResult *= varX;
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
}
FactorialComplete(varResult, varTotalAsOfNow);
}
// This method will add two to a number (varAddTwo+2).
public void AddTwo()
{
double varTotalAsOfNow = 0;
int varResult = varAddTwo + 2;
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
AddTwoComplete(varResult, varTotalAsOfNow);
}
// This method will run a loop with a nested loop varLoopValue times.
public void RunALoop()
{
int varX;
double varTotalAsOfNow = 0;
for (varX = 1; varX <= varLoopValue; varX++)
{
// This nested loop is added solely for the purpose of slowing down
// the program and creating a processor-intensive application.
for (int varY = 1; varY <= 500; varY++)
{
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
}
}
LoopComplete(varTotalAsOfNow, varLoopValue);
}下一步是向 frmCalculations 添加代码，以接收用户输入，以及从 Calculator 组件接收值和向它传输值。
实现 frmCalculations 的前端功能
public class frmCalculations 语句。紧接着 { 的下方键入： Calculator Calculator1;
// Creates a new instance of Calculator. Calculator1 = new Calculator();
完成后，单击事件处理程序应该类似于以下形式：
private void btnFactorial1_Click(object sender, System.EventArgs e)
// Passes the value typed in the txtValue to Calculator.varFact1.
{
Calculator1.varFact1 = int.Parse(txtValue.Text);
// Disables the btnFactorial1 until this calculation is complete.
btnFactorial1.Enabled = false;
Calculator1.Factorial();
}
private void btnFactorial2_Click(object sender, System.EventArgs e)
{
Calculator1.varFact2 = int.Parse(txtValue.Text);
btnFactorial2.Enabled = false;
Calculator1.FactorialMinusOne();
}
private void btnAddTwo_Click(object sender, System.EventArgs e)
{
Calculator1.varAddTwo = int.Parse(txtValue.Text);
btnAddTwo.Enabled = false;
Calculator1.AddTwo();
}
private void btnRunLoops_Click(object sender, System.EventArgs e)
{
Calculator1.varLoopValue = int.Parse(txtValue.Text);
btnRunLoops.Enabled = false;
// Lets the user know that a loop is running
lblRunLoops.Text = "Looping";
Calculator1.RunALoop();
}
protected void FactorialHandler(double Value, double Calculations)
// Displays the returned value in the appropriate label.
{
lblFactorial1.Text = Value.ToString();
// Re-enables the button so it can be used again.
btnFactorial1.Enabled = true;
// Updates the label that displays the total calculations performed
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}
protected void FactorialMinusHandler(double Value, double Calculations)
{
lblFactorial2.Text = Value.ToString();
btnFactorial2.Enabled = true;
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}
protected void AddTwoHandler(int Value, double Calculations)
{
lblAddTwo.Text = Value.ToString();
btnAddTwo.Enabled = true;
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}
protected void LoopDoneHandler(double Calculations, int Count)
{
btnRunLoops.Enabled = true;
lblRunLoops.Text = Count.ToString();
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}
Calculator1.FactorialComplete += new Calculator.FactorialCompleteHandler(this.FactorialHandler); Calculator1.FactorialMinusOneComplete += new Calculator.FactorialCompleteHandler(this.FactorialMinusHandler); Calculator1.AddTwoComplete += new Calculator.AddTwoCompleteHandler(this.AddTwoHandler); Calculator1.LoopComplete += new Calculator.LoopCompleteHandler(this.LoopDoneHandler);
现在项目已经创建完毕，该项目将能够执行若干个复杂计算的组件与窗体结合在一起。尽管尚未实现多线程处理功能，但在继续之前应该对项目进行测试，以验证它的功能。
测试项目
应用程序启动并显示 frmCalculations。
在按钮下方的标签中应该显示数字“6”，在 lblTotalCalculations 中应该显示“Total Calculations are 1”。
该按钮的下方应显示数字“6”，而 lblTotalCalculations 中现在应显示“Total Calculations are 4”。
该按钮的下方显示数字“2.43290200817664E+18”，而 lblTotalCalculations 中现在显示为“Total Calculations are 24”。
注意，在此按钮重新启用前有一个短暂然而明显的间隔。此按钮下的标签应显示“50000”，而总的计算次数显示为“25000024”。
直到循环已经完成，该按钮以及窗体上的任何控件才有响应。
如果程序只运行单个执行线程，则类似上述示例的频繁使用处理器的计算倾向于占用该程序，直到计算已经完成。在下一节中，您将向应用程序添加多线程处理功能，以便一次可以运行多个线程。
上面的示例演示了只运行单个执行线程的应用程序的限制。在下一节，您将使用
添加 Threads 子例程
// Declares the variables you will use to hold your thread objects. public System.Threading.Thread FactorialThread; public System.Threading.Thread FactorialMinusOneThread; public System.Threading.Thread AddTwoThread; public System.Threading.Thread LoopThread;
public void ChooseThreads(int threadNumber)
{
// Determines which thread to start based on the value it receives.
switch(threadNumber)
{
case 1:
// Sets the thread using the AddressOf the subroutine where
// the thread will start.
FactorialThread = new System.Threading.Thread(new
System.Threading.ThreadStart(this.Factorial));
// Starts the thread.
FactorialThread.Start();
break;
case 2:
FactorialMinusOneThread = new
System.Threading.Thread(new
System.Threading.ThreadStart(this.FactorialMinusOne));
FactorialMinusOneThread.Start();
break;
case 3:
AddTwoThread = new System.Threading.Thread(new
System.Threading.ThreadStart(this.AddTwo));
AddTwoThread.Start();
break;
case 4:
LoopThread = new System.Threading.Thread(new
System.Threading.ThreadStart(this.RunALoop));
LoopThread.Start();
break;
}
}
当实例化 Thread 对象时，它要求一个 ThreadStart 对象形式的参数。ThreadStart 对象是一个指向开始线程的方法的地址的委托。ThreadStart 对象不能接受参数或者传递值，因此只能表示 void 方法。刚才实现的 ChooseThreads 方法将从调用它的程序接收一个值，并使用该值来确定要启动的适当线程。
向 frmCalculations 添加适当的代码
// Calculator1.Factorial()
// Passes the value 1 to Calculator1, thus directing it to start the // correct thread. Calculator1.ChooseThreads(1);
注意 一定要为 Threads 参数包含适当的值。
完成后，代码看起来应该类似以下形式：
protected void btnFactorial1_Click(object sender, System.EventArgs e)
// Passes the value typed in the txtValue to Calculator.varFact1
{
Calculator1.varFact1 = int.Parse(txtValue.Text);
// Disables the btnFactorial1 until this calculation is complete
btnFactorial1.Enabled = false;
// Calculator1.Factorial();
Calculator1.ChooseThreads(1);
}
protected void btnFactorial2_Click(object sender, System.EventArgs e)
{
Calculator1.varFact2 = int.Parse(txtValue.Text);
btnFactorial2.Enabled = false;
// Calculator1.FactorialMinusOne();
Calculator1.ChooseThreads(2);
}
protected void btnAddTwo_Click(object sender, System.EventArgs e)
{
Calculator1.varAddTwo = int.Parse(txtValue.Text);
btnAddTwo.Enabled = false;
// Calculator1.AddTwo();
Calculator1.ChooseThreads(3);
}
protected void btnRunLoops_Click(object sender, System.EventArgs e)
{
Calculator1.varLoopValue = int.Parse(txtValue.Text);
btnRunLoops.Enabled = false;
// Lets the user know that a loop is running
lblRunLoops.Text = "Looping";
// Calculator1.RunALoop();
Calculator1.ChooseThreads(4);
}现在将加速窗体上的显示更新。鉴于控件总是由主执行线程所有，从属线程中对控件的任何调用都需要“封送处理”调用。封送处理是跨线程边界移动调用的行为，需要耗费大量的资源。为了使需要发生的封送处理量减到最少，并确保以线程安全方式处理调用，应使用
创建控件调用过程
public delegate void FHandler(double Value, double Calculations); public delegate void A2Handler(int Value, double Calculations); public delegate void LDHandler(double Calculations, int Count);
Invoke 和 BeginInvoke 需要将适当方法的委托作为参数。这些代码行声明一些委托签名，这些签名将被 BeginInvoke 用于调用适当的方法。
public void FactHandler(double Value, double Calculations)
{
}
public void Fact1Handler(double Value, double Calculations)
{
}
public void Add2Handler(int Value, double Calculations)
{
}
public void LDoneHandler(double Calculations, int Count)
{
}
完成后，在 FactorialHandler、Factorial1Handler、AddTwoHandler 和 LoopDoneHandler 中应该没有剩余代码，并且它们曾经包含的所有代码应该已经移动到适当的新方法中。
完成后，代码看起来应该类似以下形式：
protected void FactorialHandler(double Value, double Calculations)
{
// BeginInvoke causes asynchronous execution to begin at the address
// specified by the delegate. Simply put, it transfers execution of
// this method back to the main thread. Any parameters required by
// the method contained at the delegate are wrapped in an object and
// passed.
this.BeginInvoke(new FHandler(FactHandler), new Object[]
{Value, Calculations});
}
protected void FactorialMinusHandler(double Value, double Calculations)
{
this.BeginInvoke(new FHandler(Fact1Handler), new Object []
{Value, Calculations});
}
protected void AddTwoHandler(int Value, double Calculations)
{
this.BeginInvoke(new A2Handler(Add2Handler), new Object[]
{Value, Calculations});
}
protected void LoopDoneHandler(double Calculations, int Count)
{
this.BeginInvoke(new LDHandler(LDoneHandler), new Object[]
{Calculations, Count});
}
看起来似乎事件处理程序仅仅是对下一个方法进行调用。实际上，该事件处理程序实现了在主操作线程上调用方法。这种方法可节省跨线程边界的调用，并使多线程应用程序能够有效运行而不必担心导致死锁。有关在多线程环境下使用控件的详细信息，请参见从线程操作控件。
此按钮下方的标签中显示“Looping”。运行这个循环应该占用很长时间。如果它完成得太快，请相应地调整该数字的大小。
正如刚刚观察到的，在四个单独的线程上同时执行四组独立的计算。用户界面保持对输入的响应，并在每个线程完成后返回结果。
有经验的多线程应用程序用户可能会发现已键入的代码中存在细微缺陷。从 Calculator.cs 中每个执行计算的子例程中撤回以下代码行：
varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations;
这两行代码递增公共变量 varTotalCalculations 并将局部变量 varTotalAsOfNow 设为此值。然后，该值被返回给 frmCalculations，并显示在标签控件中。但返回的值正确吗？如果只有单个执行线程在运行，则答案明显是正确的。但是如果有多个线程在运行，答案则变得不太确定。每个线程都具有递增变量 varTotalCalculations 的能力。有可能出现这样的情况：在一个线程递增该变量之后，但在它将该值复制到 varTotalAsOfNow 之前，另一个线程可能通过递增该变量而更改它的值。这将导致有可能每个线程实际上在报告不正确的结果。Visual C# 提供
lock(AnObject)
{
// Insert code that affects the object.
// Insert more code that affects the object.
// Insert more code that affects the object.
// Release the lock.
}
输入 lock 块后，在指定的线程对所讨论的对象拥有专用锁之前，对指定表达式的执行一直被堵塞。在上面显示的示例中，对 AnObject 的执行处于锁定状态。必须对返回引用的对象（而非返回值的对象）使用 lock。然后，执行以块的形式继续进行，而不会受到其他线程的干扰。作为一个单元执行的语句集称为“原子”。当遇到 } 时，表达式将被释放，线程可继续正常工作。
将 lock 语句添加到应用程序
varTotalCalculations += 1; varTotalAsOfNow = varTotalCalculations;
应该有此代码的四个实例，每个计算方法中有一个。
lock(this)
{
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
}
您可能注意到对程序性能的细微影响。这是因为当组件获得排他锁后，线程的执行停止。尽管它保证了正确性，但这种方法抵消了多线程带来的某些性能优点。应该认真考虑锁定线程的必要性，并且仅当绝对必要时才予以实现。
本文地址：http://com.8s8s.com/it/it44538.htm