C# 多线程 详解

【基础篇】

  • 怎样创建一个线程
  • 受托管的线程与Windows线程
  • 前台线程与后台线程
  • 名为BeginXXX和EndXXX的方法是做什么用的
  • 异步和多线程有什么关联

【WinForm多线程编程篇】

  • 多线程WinForm程序总是抛出InvalidOperationException,怎么解决
  • Invoke和BeginInvoke干什么用的,内部是怎么实现的
  • 每个线程都有消息队列吗
  • 为什么WinForm不允许跨线程修改UI线程控件的值
  • 有没有什么办法可以简化WinForm多线程的开发

【线程池】

  • 线程池的作用是什么
  • 所有进程使用一个共享的线程池,还是每个进程使用独立的线程池
  • 线程池中线程的分类
  • .NET线程池有什么不足

【同步】

  • CLR怎样实现lock(obj)锁定
  • 互斥对象(Mutex)、事件(Event)对象与lock语句的比较

基础篇

怎样创建一个线程

方法一:使用Thread类

   public static void Main(string[] args)
        {
            //方法一:使用Thread类
            ThreadStart threadStart = new ThreadStart(Calculate);//通过ThreadStart委托告诉子线程执行什么方法                        Thread thread = new Thread(threadStart);
            thread.Start();//启动新线程
        }

public static void Calculate()
        {
            Console.Write("执行成功");
            Console.ReadKey();
        }

方法二:使用Delegate.BeginInvoke

   delegate double CalculateMethod(double r);//声明一个委托,表明需要在子线程上执行的方法的函数签名
        static CalculateMethod calcMethod = new CalculateMethod(Calculate);

   static void Main(string[] args)
        {
            //方法二:使用Delegate.BeginInvoke
            //此处开始异步执行,并且可以给出一个回调函数(如果不需要执行什么后续操作也可以不使用回调)
            calcMethod.BeginInvoke(5, new AsyncCallback(TaskFinished), null);
            Console.ReadLine();
        }

   public static double Calculate(double r)
        {
            return 2 * r * Math.PI;
        }
        //线程完成之后回调的函数
        public static void TaskFinished(IAsyncResult result)
        {
            double re = 0;
            re = calcMethod.EndInvoke(result);
            Console.WriteLine(re);
        }

方法三:使用ThreadPool.QueueworkItem

受托管的线程与Windows线程

  .NET应用的线程实际上仍然是Windows线程。但是,当某个线程被CLR所知时,我们将它称为受托管的线程。具体来说,由受托管的代码创建出来的线程就是受托管的线程。不过,一旦该线程执行了受托管的代码它就变成了受托管的线程。

  一个受托管的线程和非受托管的线程的区别在于,CLR将创建一个System.Threading.Thread类的实例来代表并操作前者。在内部实现中,CLR将一个包含了所有受托管线程的列表保存在一个叫做ThreadStore地方。

  CLR确保每一个受托管的线程在任意时刻都在一个AppDomain中执行,但是这并不代表一个线程将永远处在一个AppDomain中,它可以随着时间的推移转到其他的AppDomain中。

前台线程与后台线程

  启动了多个线程的程序在关闭的时候却出现了问题,如果程序退出的时候不关闭线程,那么线程就会一直的存在,但是大多启动的线程都是局部变量,不能一一的关闭,如果调用Thread.CurrentThread.Abort()方法关闭主线程的话,就会出现ThreadAbortException异常。可以通过这个方法:Thread.IsBackground设置线程为后台线程。

  msdn对前台线程和后台线程的解释:托管线程或者是后台线程,或者是前台线程。后台线程不会是托管执行环境处于活动状态,除此之外,后台线程与前台线程是一样的。一旦所有前台进程在托管进程(其中.exe文件时托管程序集)中被停止,系统将停止所有后台线程并关闭。通过设置Thread.IsBackground属性,可以将一个线程指定为后台线程或者前台线程。从非托管代码进入托管执行环境的所有线程都被标记为后台线程。通过创建并启动新的Thread对象而生成的所有线程都是前台线程。

名为BeginXXX和EndXXX的方法是做什么用的

  这是.net的一个异步方法名称规范。

  .net在设计的时候为异步编程设计了一个异步编程模型(APM),比如所有的Stream就是BeginRead,EndRead,Socket,WebRequet,SqlCommand都运用到了这个模式,一般来讲,调用BeginXXX的时候,一般会启动一个异步过程去执行一个操作,EndInvoke可以接受这个异步操作的返回,当然如果异步操作在EndIncoke调用的时候还没有执行完成,EndInvoke会一直等待异步操作完成或者超时。

  .NET的异步编程模型(APM)一般包含BeginXXX,EndXXX,IAsyncResult这三个元素,BeginXXX方法都有返回一个IAsyncResult,而EndXXX都需要接受一个IAsyncResult作为参数。

异步和多线程

  异步有许多种方法,我们可以用进程来做异步,或者使用线程,或者硬件的一些特性,比如在实现异步IO的时候,可以以下两种方案:

  方案一:可以通过初始化一个子线程,然后在子线程里进行IO,而让主线程顺利往下执行,当子线程执行完毕就回调

  方案二:使用硬件的支持(现在许多硬件都有自己的处理器),来实现完全的异步,这时我们只需将IO请求告知硬件驱动程序,然后迅速返回,然后等着硬件IO就绪通知我们就可以了

WinForm多线程编程篇

多线程WinForm程序总是抛出InvalidOperationException,怎么解决

  在WinForm中使用线程时,常常遇到一个问题,当在子线程(非UI线程)中修改一个空间的值:比如修改进度条进度,时会抛出异常。

  解决方法就是利用控件提供的Invoke和BeginInvoke把调用封送回UI线程,也就是让控件属性修改在UI线程上执行。

  例如:

   delegate void changeText(double result);
        public Form1()
        {
            InitializeComponent();
            ThreadStart threadStart = new ThreadStart(Calculate);
            Thread thread = new Thread(threadStart);
            thread.Start();
        }

public void Calculate()
        {
            double r = 2;
            double result = 2 * Math.PI * r;
            CalcFinished(result);
        }
        public void CalcFinished(double result)
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new changeText(CalcFinished), result);
            }
            else
            {
                this.textBox1.Text = result.ToString();
            }
        }

  这里用到了Control的一个属性InvokeRequired(这个属性石可以在其它线程里访问),这个属性表明调用是否来自非UI线程,如果是,使用BeginInvoke来调用这个函数,否则就直接调用,省去线程封送的过程。

Invoke和BeginInvoke干什么用的,内部是怎么实现的

  这两个方法主要是让给出的方法在控件创建的线程上执行。

  Invoke使用了Win32API的SendMessage     BeginInvoke使用了Win32API的PostMessage

  这两个方法想UI线程的消息队列中放入一个消息,当UI线程处理这个消息时,就会在自己的上下文中执行传入的方法,换句话说,凡是使用BeginInvoke和Invoke调用的线程都是在UI主线程中执行,所以如果这些方法里涉及一些静态变量,不用考虑加锁的问题。

每个线程都有消息队列吗?

  不是,知识创建了窗体对象的线程才会有消息队列(下面是《Windows核心编程》关于这一段的描述)

  当一个线程第一希被建立时,系统假定线程不会被用于任何与用户相关的任务。这样可以减少线程对系统资源的要求。但是,一旦这个线程调用一个与图形用户界面有关的函数(例如检查它的消息队列或建立一个窗口),系统就会为该线程分配一些另外的资源,以便它能够执行与用户界面有关的任务。特别是,系统分配一个THREADINFO结构,并将这个数据结构与线程联系起来。

  这个THREADINFO结构包含一组成员变量,利用这组成员,线程可以认为它是在自己独占的环境中运行。THREADINFO是一个内部的、未公开的数据结构,用来指定线程的登记消息队列(posted-message queue)、发送消息队列(send-message queue)、应答消息队列(reply-message queue)、虚拟输入队列(virtualized-input queue)、唤醒标志(wake flag)以及用来描述线程局部输入状态的若干变量。

为什么WinForm不允许跨线程修改UI线程控件的值

  vs2005及以上版本,当在Visual Studio调试器中运行代码时,如果您从一个线程访问某个UI元素,而该线程不是创建该UI元素时所在的线程,则会引发InvalidOperationException调试器引发该异常以警告您存在危险的编程操作。UI元素不是线程安全的,所以只应在创建它们的线程上进行访问。

有没有什么办法可以简化WinForm多线程的开发

  使用backgroundworker,使用这个组件可以避免回调时的Invoke和BeginInvoke,并且提供了许多丰富的方法和事件

线程池

线程池的作用是什么

  减小线程创建和销毁的开销

   创建线程涉及到用户模式和内核模式的切换,内存分配,dll通知等一系列过程,线程销毁的步骤也是开销很大的,所以如果应用程序使用完一个线程,我们能把线程暂时存放起来,以备下次使用,就可以减小这些开销。

所有进程使用一个共享的线程池,还是每个进程使用独立的线程池

  每个进程都有一个线程池,一个进程中只能有一个实例,它在各个应用程序域(AppDomain)是共享的,线程池仅仅保留相当少的线程,保留的线程可以用SetMinThread这个方法设置,当程序需要一个线程时,线程池中没有空闲的线程时,线程池就会负责创建这个线程,调用完后,不会立即销毁,而是把它放在池子里,以备下次使用,但是,如果超出一定时间没使用,线程池就会回收线程,所以线程池里存在的线程数实际是个动态的过程。

线程池中线程的分类

  线程池里的线程按照公用被分成了两大类:工作线程和IO线程(IO完成线程),前者用于执行普通操作,后者专用于异步IO。它们分别在什么情况下被使用,二者工作原理有什么不同?通过下面这个例子,我们用一个流读出一个很大的文件(文件大,操作时间长,便于观察),然后用另一个输出流把所读出的文件的一部分写到磁盘上。

  用两种方法创建输出流,分别是:

  创建一个异步的流(注意构造函数最后那个true)

  创建一个同步流

   string readPath = "d:\\工作常用软件\\VS2012Documentation.iso";
        string writePath = "d:\\vs2012.ios";
        byte[] buffer = new byte[90000000];
        //创建一个异步流
        FileStream outputfs = new FileStream(writePath, FileMode.Create, FileAccess.Write, FileShare.None, 256, true);
        Console.WriteLine("异步流");
        //创建一个同步流
        //FileStream outputfs = File.OpenWrite(writePath);
        //Console.WriteLine("同步流");
        //然后在写文件期间查看线程池的状况
        ShowThreadDetail("初始状态");
        FileStream fs = File.OpenRead(readPath);
        fs.BeginRead(buffer, 0, 90000000, delegate(IAsyncResult o)
        {
            outputfs.BeginWrite(buffer, 0, buffer.Length, delegate(IAsyncResult o1)
            {
                Thread.Sleep(1000);
                ShowThreadDetail("BeginWrite的回调线程");
            }, null);
            Thread.Sleep(500);
        },
        null);
        Console.ReadLine();

   public static void ShowThreadDetail(string caller)
        {
            int IO;
            int Worker;
            ThreadPool.GetAvailableThreads(out Worker, out IO);
            Console.WriteLine("Worker:{0};IO:{1}", Worker, IO);
        }

  输出结果

  异步流

  Worker:1023;    IO:1000

  Worker:1023;    IO:999

  同步流

  Worker:1023;    IO:1000

  Worker:1022;    IO:1000

  这两个构造函数创建的流都可以使用BeginWrite来异步写数据,但二者行为不同,当使用同步的流进行异步写时,通过回调的输出我们可以看到,它使用的是工作线程,而非IO线程,而异步流使用IO线程。

.NET线程池有什么不足

  没有提供方法控制加入线程池的线程:一旦加入线程池,我们没办法挂起,终止这些线程,唯一可以做的就是等他自己执行

  • 不能为线程设置优先级
  • 所支持的Callback不能有返回值。WaitCallback只能带一个object类型的参数
  • 不适合用于长期执行某任务的场合

同步

CLR怎样实现lock(obj)锁定

  从原理上讲,lock和Syncronized Attribute都是用Moniter.Enter实现的,例如:

  object obj = new object();

  lock(obj){

  //do things...

  }

  在编译时,会被编译为类似

  try{

    Moniter.Enter(obj){

    //do things...

    }

  }

  catch{...}

  finally{

    Moniter.Exit(obj);

  }

  每个对象实例头部都有一个指针,这个指针指向的结构包含了对象的锁定信息,当第一次使用Moniter.Enter(obj)是,这个obj对象的锁定结构就会被初始化,第二次调用时,会检验这个object的锁定结构,如果锁没有被释放,则调用会阻塞。

互斥对象(Mutex)、事件(Event)对象与lock语句的比较

  这里所谓的事件是一种用于同步的内核机制,互斥对象和事件对象属于内核对象,利用内核对象进行线程同步,线程必须要在用户模式和内核模式间切换,所有一般效率很低,但利用互斥对象和事件对象这样的内核对象,可以在多个线程中的各个线程间进行同步。

  lock或者Moniter是.net用于一种特殊结构实现的,不涉及模式切换,就是工作在用户方式下,同步速度较快,但是不能跨进程同步。

上一篇:MS14-025引起的问题 - 2


下一篇:sqlserver 数据行统计,秒查语句