petshop4.0学习笔记之多线程

一直搞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下载:

http://ljzforever.qupan.com/?folder=951925