.net多线程与异步小结

A、Thread，分两种，实例时带入一个委托，System.Threading.ThreadStart是无参数委托，System.Threading.ParameterizedThreadStart是带参数委托，这两个委托都是现成的

不带参数

 Thread thread=new Thread(ThreadStart start);    

带参数

Thread thread=new Thread(ParameterizedThreadStart start);    

 

不带参数例子： 在form的label上刷新当前时间

 

 Thread thread = new Thread(new ThreadStart(() =>            {                while (true)                    this.Invoke(new MethodInvoker(() => { label1.Text = DateTime.Now.ToString(); }));            }));            thread.Start();

 

带参数例子   ParameterizedThreadStart委托带一个object的形参，说明带啥参数都是可以的

  

Thread thread = new Thread(new ParameterizedThreadStart((s) =>            {                while (true)                    this.Invoke(new MethodInvoker(() => { label1.Text = (string)s + DateTime.Now.ToString(); }));            }));            thread.Start("带参数");

 

 

 

 

B、ThreadPool,线程池允许在后台运行多个工作，而不需要为每个任务频繁地创建和销毁单独的线程，从而减少了开销。此类是一个静态类  其静态方法 public static bool QueueUserWorkItem(WaitCallback callBack);用于将方法排入队列以便执行。此方法在有线程池线程变得可用时执行。WaitCallback也是个带object形参的现成委托和ParameterizedThreadStart类似

例子：直接把匿名方法扔进去就开始运行了，只是要注意线程池的可用值，可用即执行。

  

 ThreadPool.QueueUserWorkItem(new WaitCallback((s) =>            {                while (true)                    this.Invoke(new MethodInvoker(() => { label1.Text = (string)s + DateTime.Now.ToString(); }));            }), "带参数"); 

 

 

 

C、异步AsyncCallback  又是一个现成的委托，注意带入形参的类型是IAsyncResult，注意IAsyncResult这个接口下有个object AsyncState { get; } 

 

例子：两个例子的区别只在AsyncState是什么？

1、  

public partial class Form1 : Form    {        delegate void MyHandler(string s);        public Form1()        {            InitializeComponent();            MyHandler handler = new MyHandler((s) =>            {                for (int i = 0; i < 10000; i++)                    this.Invoke(new MethodInvoker(() => { label1.Text = s + i.ToString(); }));            });            AsyncCallback callback = new AsyncCallback(MyCallBack);            handler.BeginInvoke("带参数", callback , handler);  //注意第三个object类型的参数，其实就是AsyncState，所以把handler放进去在回调里显式转换一下就是委托了        }        public void MyCallBack(IAsyncResult ar)     //回调函数，线程处理完执行的方法        {            ((MyHandler)ar.AsyncState).EndInvoke(ar);        }    }

 

 

 2、 

public partial class Form1 : Form    {        delegate void MyHandler(string s);        public Form1()        {            InitializeComponent();            MyHandler handler = new MyHandler((s) =>            {                for (int i = 0; i < 10000; i++)                    this.Invoke(new MethodInvoker(() => { label1.Text = s + i.ToString(); }));            });            AsyncCallback callback = new AsyncCallback(MyCallBack);            handler.BeginInvoke("带参数", callback , "回调完毕"); //此处第三个参数把AsyncState用来传值（或者直接设为null），回调方法里就不一样        }        public void MyCallBack(IAsyncResult ar)     //回调函数，线程处理完执行的方法        {            MyHandler handler = (MyHandler)((AsyncResult)ar).AsyncDelegate;            handler.EndInvoke(ar);            this.Invoke(new MethodInvoker(() => { label1.Text += ar.AsyncState; }));        }    }

 

 

D、由C联想到文件IO的异步、网络的异步，其实大同小异

 文件IO异步例子

 

public partial class Form1 : Form    {        const int bufferSize = 10;             byte[] data = new byte[bufferSize];        List<byte> totalData = new List<byte>();        AsyncCallback callback;        public Form1()        {            InitializeComponent();            FileStream fs = new FileStream("Test.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 10240, true);            callback = new AsyncCallback(MyCallBack);            fs.BeginRead(data, 0, bufferSize, callback, fs); //BeginRead背后的实现其实是这样的：ReadDelegate delegate2 = new ReadDelegate(this.Read);   delegate2.BeginInvoke(buffer, offset, count, callback, state);   多么熟悉            }        public void MyCallBack(IAsyncResult ar)        {            FileStream fs = (FileStream)ar.AsyncState;            int bytesRead = fs.EndRead(ar);            if (bytesRead > 0)            {                fs.BeginRead(data, 0, bufferSize, callback, fs);                totalData.AddRange(data);                Array.Clear(data, 0, bufferSize);            }            else          //读完一起显示            {                this.Invoke(new MethodInvoker(() => { label1.Text = Encoding.Default.GetString(totalData.ToArray()); }));                fs.Close();            }        }    }

网络接收的例子

 public partial class Form1 : Form    {        const int bufferSize = 4096;        byte[] buffer = new byte[bufferSize];        AsyncCallback callback;        public Form1()        {            InitializeComponent();            ThreadPool.QueueUserWorkItem(new WaitCallback((o) =>            {                IPAddress ip = IPAddress.Parse("127.0.0.1");                TcpListener listener = new TcpListener(ip, 8888);                listener.Start();                while (true)          //循环处理，可以同时支持多个client                {                    TcpClient client = listener.AcceptTcpClient();                    NetworkStream stream = client.GetStream();                    callback = new AsyncCallback(MyCallBack);                    stream.BeginRead(buffer, 0, bufferSize, callback, client);//最后一个参数把TcpClient放进去，回调中就可以分别处理不同的Client了                }            }));        }        public void MyCallBack(IAsyncResult ar)        {            TcpClient client = (TcpClient)ar.AsyncState;                //把TcpClient取出来，AsyncState真是好东西            NetworkStream stream = client.GetStream();            int bytesRead = stream.EndRead(ar);            try            {                if (bytesRead > 0)   //有数据                {                    this.Invoke(new MethodInvoker(() => { label1.Text += Encoding.Unicode.GetString(buffer, 0, bytesRead); }));                    Array.Clear(buffer, 0, buffer.Length);                }                stream.BeginRead(buffer, 0, bufferSize, callback, client);            }            catch (Exception)            {                if (stream != null)                    stream.Dispose();                client.Close();            }        }    }

为了方便上面程序调试给个发送数据的例子

static void Main(string[] args)        {            TcpClient client;            try            {                client = new TcpClient();                client.Connect("localhost", 8888);                while (true)                {                    string msg = Console.ReadLine();                    NetworkStream stream = client.GetStream();                    byte[] buffer = Encoding.Unicode.GetBytes(msg);                    stream.Write(buffer, 0, buffer.Length);                    Console.WriteLine("发送: {0}", msg);                }            }            catch (Exception ex)            {                Console.WriteLine(ex.Message);            }        }

E、BackgroundWorker    也是用来执行多线程任务的一个控件，其有三个事件，用起来比较优雅，也经常配合进度条使用，ReportProgress会触发ProgressChanged事件，从而实现进度刷新

BackgroundWorker worker = new BackgroundWorker();            worker.WorkerReportsProgress = true;  //报告进度            worker.DoWork += (sender, e) =>            {                for (int i = 0; i <= 10000; i++)                    this.Invoke(new MethodInvoker(() => { label1.Text = i.ToString(); worker.ReportProgress(i / 100, null); }));            };            worker.RunWorkerCompleted += (sender, e) =>            {                this.Invoke(new MethodInvoker(() => { label1.Text += "执行完毕"; }));            };            worker.ProgressChanged += (sender, e) =>            {                progressBar1.Style = ProgressBarStyle.Continuous;                progressBar1.Value = e.ProgressPercentage;            };            worker.RunWorkerAsync();