尽量的避免问题，我们最好不要在线程之间共享数据。如果要共享数据，就必须使用同步技术：确保一次只有一个线程访问和改变共享数据。其中不可避免的要用到“锁”。使用锁是需要时间的，并且，也不是总是必须的。所以对于一个类，我们可以创建一个类的2个版本，一个同步版本，一个异步版本。下面请看这个例子：
public class SynDemo
{
public virtual bool IsSynchronized
{
get { return false; }
}
public virtual void doThis()
{
//dothis
}
public virtual void doThat()
{
//doThat
}
public static SynDemo SynchronizeDemo(SynDemo d)
{
if (!d.IsSynchronized)
{
return new SynchronizedDemo(d);
}
return d;
}
private class SynchronizedDemo : SynDemo
{
private SynDemo _demo;
private object _synRoot =new object();
public SynchronizedDemo(SynDemo d)
{
this._demo = d;
}
public override bool IsSynchronized
{
get
{
return true;
}
}
public override void doThat()
{
lock(_synRoot)
{
_demo.doThat();
}
}
public override void doThis()
{
lock(_synRoot)
{
_demo.doThis();
}
}
}
}
在c#中如何给线程传递参数呢？其实很简单。一般来说可以采用2种方式：
- 使用带parameterizeThreadStart委托参数的Thread构造函数
- 定制一个类，通过该类的构造函数初始化想要传递的参数，再将该参数应用该类的方法。把线程的方法定义为该类实例的方法即可。
下面是一个Demo ：
public static void Main()
{
//1.使用一个带参数的委托ParameterizedThreadStart来初始化Thread
myData data = new myData();
data.Message = "new Info";
new Thread(paralizeThread).Start(data);
//2.通过初始化一个类的字段，将该类的方法封装到线程中去
new Thread(new myThreadClass("new info2").ThreadMethod).Start();
}
//类或结构都行
struct myData
{
string message;
public string Message
{
get { return message; }
set { message = value; }
}
}
static void paralizeThread(object o)
{
myData data = (myData)o;
Console.WriteLine("Thread {1} received a Parameter : {0}",data.Message,Thread.CurrentThread.ManagedThreadId);
}
class myThreadClass
{
string _message;
public myThreadClass(string message)
{
this._message = message;
}
public void ThreadMethod()
{
Console.WriteLine("Thread {1} received a Parameter : {0}", this._message, Thread.CurrentThread.ManagedThreadId);
}
}
异步委托，首先要搞明白，为什么要用到异步委托。
长时间以来，我个人在编写代码的时候，都认为程序应该是执行完一件事之后，然后再干接下来的。这用计算机术语来讲，叫同步执行（Synchronous Execution）。但事实上，这样的执行效果不一定人性化。举下面的一组对照：
- 你有3份快件需要传递给远程客户。如果这件事由你本人亲自完成，那么，接下来，你将要停下手中的工作，跑3段路程，分别将这3个快件递交给3个不同的客户。然后返回公司继续执行你手上剩下的工作。现实生活中，这样的事情或许永远不会发生，因为聪明的你会打一个电话叫来快递专员来为你解决快件问题。
- 刚入学那会，写了一个资源转换工具。那个时候还没意识到出现了这样的问题：当我执行转换的时候，UI 无法继续响应用户的操作，而只有当转换完毕之后才恢复正常。实际上，现在分析起来，就是主线程没空搭理你，它正忙，忙完之后才能执行你的更新的操作。这个处境和之前的那个跑3段路传递3个快件的境遇差不多。.net 为我们设计了这个异步委托来执行类似快递专员的工作。
搞懂异步委托，需要理解BeginInvoke() ,EndInvoke() ,IAsyncResult 以及AsyncCallback 委托:
异步委托提供以异步方式调用同步方法的能力。当同步调用一个委托时，“Invoke”方法直接对当前线程调用目标方法。如果编译器支持异步委托，则它将生成“Invoke”方法以及“BeginInvoke”和“EndInvoke”方法。如果调用“BeginInvoke”方法，则公共语言运行库 (CLR) 将对请求进行排队并立即返回到调用方。将对来自线程池的线程调用该目标方法。提交请求的原始线程自由地继续与目标方法并行执行，该目标方法是对线程池线程运行的。如果在对“BeginInvoke”方法的调用中指定了回调方法，则当目标方法返回时将调用该回调方法。在回调方法中，“EndInvoke” 方法获取返回值和所有输入/输出参数。如果在调用“BeginInvoke”时未指定任何回调方法，则可以从调用“BeginInvoke”的线程中调用“EndInvoke”。
下面，我用一个例子，谈谈可能发生的4种情况
class Programe
{
private delegate void ADelegateSomewhat(int x);
public static void Main()
{
ADelegateSomewhat aD = MathPupil;
////1.直接调用EndInvoke,这和直接调用MathPupil(100)的效果一样，
////但会等到这个方法执行完之后才去执行后面的语句
//IAsyncResult ar= aD.BeginInvoke(100,null,null);
//aD.EndInvoke(ar);
////2.轮询,每隔50毫秒看看孩子算完了没.
//IAsyncResult ar = aD.BeginInvoke(200, null, null);
//while (!ar.IsCompleted)
//{
// Console.Write(".");
// Thread.Sleep(500);
//}
//aD.EndInvoke(ar);
////3.实际上和2的方法类似，只是把Sleep的时间放上来了
////但事实上，功能会多点,比如控制跳出的条件等
//IAsyncResult ar = aD.BeginInvoke(300,null,null);
//while (!ar.AsyncWaitHandle.WaitOne(500))
//{
// Console.Write(".");
//}
//aD.EndInvoke(ar);
//4.回调函数,最有意义,设置相对麻烦点
IAsyncResult ar = aD.BeginInvoke(400, MathCallBack, aD);
//现在干点别的事，不用关心算算术题的孩子了。
//由delegate的回调方法自动来管理
Console.ReadLine();
//如果不等待委托完成其任务就结束主线程，委托线程就会停止
}
//假装自己一个小学生处理一道加法算术题，历时5秒钟
static void MathPupil(int x)
{
Console.WriteLine("Now I'll pretend to be a pupil");
int sum = 0;
for (int i = 0; i < x; i++)
{
sum += i;
Thread.Sleep(5000/x);
}
Console.WriteLine("After 5 secends, i've got the answer :" +sum);
}
static void MathCallBack(IAsyncResult ar)
{
ADelegateSomewhat aD = (ADelegateSomewhat)ar.AsyncState;
aD.EndInvoke(ar);
}
}我想，到目前为止，应该收回之前提到委托“从来不是一个重点”的言论了。
参考资料：<MSDN-magazine>:Asynchronous Method Execution Using Delegates
之前看反射那一章，真把个人看郁闷了。不巧的是，看到很多业内人士的专业博客说，不会这个也搞了几年的项目开发。哎。顿时打消了学习这个知识的念头。不过，挺巧的是，今天又遇到了一个讲这个内容的章节，只不过内容更具体了。
这样一个动态调用的程序，貌似实现了一个编译器的功能。在Textbox里写上代码，能在程序下方看到编译结果。有趣的是，当代码出错的时候，能在程序中看到错误信息：
//核心代码
public string ComplieAndRun(string input,out bool hasError)
{
CompilerResults cResults = null;
string returnData = null;
hasError = false;
using(Microsoft.CSharp.CSharpCodeProvider provider =new CSharpCodeProvider())
{
StringBuilder sb = new StringBuilder();
sb.Append(prefix);
sb.Append(input);
sb.Append(postfix);
CompilerParameters option = new CompilerParameters();
option.GenerateInMemory = true;
cResults=provider.CompileAssemblyFromSource(option, sb.ToString());
}
if (cResults.Errors.HasErrors)
{
hasError = true;
StringBuilder errMessage = new StringBuilder();
foreach (CompilerError err in cResults.Errors)
{
errMessage.AppendFormat("{0}:{1}", err.Line, err.ErrorText);
}
returnData = errMessage.ToString();
}
else
{
TextWriter temp=Console.Out;
StringWriter sw = new StringWriter();
Console.SetOut(sw);
Type myType = cResults.CompiledAssembly.GetType("myDriver");
myType.InvokeMember("Run", BindingFlags.InvokeMethod|BindingFlags.Public | BindingFlags.Static, null, null, null);
Console.SetOut(temp);
returnData = sw.ToString();
}
return returnData;
}
}
//每次动态调用后，通过应用程序域卸载掉
public class DynamicRunAppInDomain
{
public string CompileAndRun(string input,out bool hasErr)
{
AppDomain app = AppDomain.CreateDomain("DynamicRun");
DynamicRun dr = (DynamicRun)app.CreateInstanceAndUnwrap("ShaoMingboDrive", "WpfApplication1.DynamicRun");
string res = dr.ComplieAndRun(input,out hasErr);
AppDomain.Unload(app);
return res;
}
}这里是一个该程序的二进制文件：动态调用demo (31).net framework 3.5 required
如果您的机器上没有安装.net，不妨下载这个打包好的文件：动态调用Setup (32)
最近评论