一直搞web开发,每天接触最多的就是asp.net+css+js,看了看petshop,原来多线程在Web项目中也有很大作用.加之以前一直对多线程不甚了解,这次就这个机会来一次自我补习吧.
启用一个新线程有四种写法:
第一种:使用Thread与ThreadStart/ParameterizedThreadStart类
static void Main(string[] args)
{
Thread th = new Thread(new ThreadStart(Print));
Thread thp = new Thread(new ParameterizedThreadStart(Print));
th.Start();
thp.Start("ljzforever");
for (int i = 0; i < 100; i++)
{
Console.WriteLine(i.ToString() + "-------------------");
}
Console.Read();
}
static void Print()
{
for (int i = 0; i < 100; i++)
{
Console.WriteLine(i.ToString());
}
}
static void Print(object obj)
{
for (int i = 0; i < 100; i++)
{
Console.WriteLine(i.ToString() + (obj==null ? "" : obj.ToString()));
}
}
ThreadStart类与ParameterizedThreadStart类区别就是前者不能传参,而后者可以.
在2.0支持匿名委托的基础上,ThreadStart类与ParameterizedThreadStart类可以不写:
Thread th = new Thread(Print); Thread thp = new Thread(Print);
这种开启线的方式有个限制,就是其包装的方法的方法签名必须与委托一致:无返回值,无参或者只有一个object型参数.
第二种:使用线程池:
class Program
{
static void Main(string[] args)
{
ThreadPool.QueueUserWorkItem(Print, "+++");
for (int i = 0; i < 100; i++)
{
Console.WriteLine();
}
Console.Read();
}
static void Print(object obj)
{
for (int i = 0; i < 100; i++)
{
Console.WriteLine(i.ToString() + (obj == null ? "" : obj.ToString()));
}
}
}
如无特殊要求,这种方法是可以使用的,它让.net自行维护线程资源的开启与释放.
以上两种方法都有很大限制,就是不能让任意方法开启线程,当然,这是有方法解决的,就是把你需要的方法再封装成与委托相对应的签名,这无疑是把问题搞复杂了,所以就有了以下两种方法:
第三种:使用Asynchronous Results模式
delegate int GetNumberHandler(string pre, string last);
static void Main(string[] args)
{
GetNumberHandler getNumber = GetNumber;
IAsyncResult asyn = getNumber.BeginInvoke("###", "%%%", Complete, "ljzforever");
for (int j = 0; j < 100; j++)
{
Console.WriteLine(j.ToString());
}
Console.ReadKey();
}
static int GetNumber(string pre, string last)
{
int j = 0;
for (int i = 0; i < 100; i++)
{
Console.WriteLine(pre + i.ToString() + last);
j += i;
}
return j;
}
static void Complete(IAsyncResult result)
{
Console.WriteLine(result.AsyncState.ToString());
GetNumberHandler getNumber = (result as AsyncResult).AsyncDelegate as GetNumberHandler;
Console.WriteLine(getNumber.EndInvoke(result).ToString());
}
说白了,就是给你需要开启线程的方法声明一个委托,然后用委托封装方法,最后执行委托的BeginInvoke方法.就会自己开启一个线程了,然后用EndInvoke方法来获取执行结果.其中其第一,二个参数是与你声明的委托有关的,委托有几个参数,这里就需要几个参数,其中in与ref参数需要写在BeginInvoke内,ref与out参数需要写在EndInvoke内,如:
delegate bool Handler(string str, ref object obj, out object obj2) BeginInvoke(string str, ref object obj) EndInvoke(ref object obj, out object obj2)
后面两个是固定参数.前一个是当异步线程结束时会调用的方法,后一个是传给结束调用方法的参数.从result.AsyncState获取.上面的Demo内有交待,就不多说了.
这种方法最灵活,但是如果你想对异步的线程有更多的控制时,就可以使用第四种方法:
第四种:Background Worker模式
static BackgroundWorker bw = new BackgroundWorker();
static void Main(string[] args)
{
bw.DoWork += new DoWorkEventHandler(bw_DoWork);
bw.WorkerReportsProgress = true;
bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
bw.WorkerSupportsCancellation = true;
bw.RunWorkerAsync();
Console.Read();
}
static void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Cancelled == true)
{
Console.WriteLine("NONComplete----------------");
}
else
{
Console.WriteLine("Complete----------------" + e.Result.ToString());
}
}
static void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
Console.WriteLine(e.ProgressPercentage + "%" + "----------" + e.UserState.ToString());
if (e.ProgressPercentage == 10)
{
bw.CancelAsync();
}
}
static void bw_DoWork(object sender, DoWorkEventArgs e)
{
int result = 0;
for (int i = 0; i < 100; i++)
{
result += i;
Console.WriteLine(i.ToString());
bw.ReportProgress(i, i);
if (bw.CancellationPending)
{
e.Cancel = true;
break;
}
}
e.Result = result;
}
将要异步执行的方法加入DoWork委托,将要进行进度控制的方法加入ProgressChanged 委托并将WorkerReportsProgress 设为true,通过ReportProgress()方法来触发进程控制.将线程完成时需要执行的方法加入RunWorkerCompleted委托,如果中途想中段进程,需要将WorkerSupportsCancellation 属性设为True,并通过调用CancelAsync()方法来中断进程.通过CancellationPending属性来判断进程是否被中断.最后,通过RunWorkerAsync()方法来启动线程.
这种方法给予我们强大的线程控制能力,不过它的弱点也很明显,就是被它封装的方法必须满足它的方法签名.
从上面看来多线程似乎很简单,其实不然,多线程难点之一就是线程同步,就是对同一对象同一时间只能有一个线程进行访问.net中是能过Monitor与lock关键字来进行同步的:
const int nMax = 1000000;
static int nCount = 0;
static object obj = new object();
static void Main(string[] args)
{
//ThreadPool.QueueUserWorkItem(Change);
Thread th = new Thread(Change);
th.Start();
for (int i = 0; i < nMax; i++)
{
Monitor.Enter(obj);
nCount++;
Monitor.Exit(obj);
}
th.Join();
Console.WriteLine(nCount.ToString());
Console.ReadKey();
}
static void Change()
{
for (int i = 0; i < nMax; i++)
{
Monitor.Enter(obj);
nCount--;
Monitor.Exit(obj);
}
}
比如++与--操作,虽然是一个操作符,但实际.net运算中是分为多个步骤进行的,如果一个步骤没有进行完就切换成另一个线程操作,其结果就只能是得不到想要的结果,办法就是加入上面所示的代码来强制保证执行的完整性.不过因为使用了同步,所以性能会有一定程度的损失.上面的例子请用百万以上的数字进行测试.
下面来谈谈winform下的多线程.上面的例子全是在控制台下执行的,而winform下的多线程则大同小异:
public Form1()
{
InitializeComponent();
}
private void btnChange_Click(object sender, EventArgs e)
{
Thread th = new Thread(Change);
th.Start();
}
public void Change()
{
if (lblTitle.InvokeRequired)
{
MethodInvoker invoke = Change;
Invoke(invoke);
}
else
{
lblTitle.Text = "改变啦!";
}
}
private void btnChange2_Click(object sender, EventArgs e)
{
Thread th = new Thread(Change2);
th.Start(txtContent.Text.Trim());
}
delegate void Change2Handler(object obj);
public void Change2(object obj)
{
if (lblTitle.InvokeRequired)
{
Change2Handler invoke = Change2;
Invoke(invoke, obj);
}
else
{
lblTitle.Text = obj.ToString();
}
}
在winform下,控件只能被它创建的控制调用.如果想被另一个线程访问,则需要进行判断:
InvokeRequired
InvokeRequired需要比较调用线程ID和创建线程ID,如果它们不相同则返回true,这时,就需要用一个委托对此方法时行封装,如上面的系统委托MethodInvoker 与 自己编写的委托 Change2Handler.然后调用Invoke方法,通知创建线程来执行这个委托.
当然,还有另外一个方法:
Control.CheckForIllegalCrossThreadCalls = false;
如果设成false.net就不会对进程间调用进行检查,这样就可以跨线程对控件进行操作.
Demo下载:
扫一扫
170
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
