干货分享：详解线程的开始和建立

时间  2019-11-20
标签 干货 分享 详解 线程 开始 建立 繁體版
原文   原文链接

原文地址：C#多线程之旅(2)——建立和开始线程
html

C#多线程之旅目录：git

C#多线程之旅(1)——介绍和基本概念github

C#多线程之旅(2)——建立和开始线程web

C#多线程之旅(3)——线程池多线程

C#多线程之旅(4)——APM初探app

C#多线程之旅(5)——同步机制介绍函数

C#多线程之旅(6)——详解多线程中的锁post

更多文章正在更新中，敬请期待......url

C#多线程之旅(2)——建立和开始线程spa

代码下载

Thread_博客园_cnblogs_jackson0714.zip

第一篇~第三篇的代码示例：

源码地址：https://github.com/Jackson0714/Threads

 

1、线程的建立和开始

在第一篇的介绍中，线程使用Thread 类的构造函数来建立，经过传给一个ThreadStart 委托来实现线程在哪里开始执行。下面是ThreadStart的定义：

// Summary:
//     Represents the method that executes on a System.Threading.Thread.
[ComVisible(true)]
public delegate void ThreadStart();

调用一个Start方法，而后设置它开始运行。线程会一直运行直到这个方法返回，而后这个线程结束。

下面是一个例子，使用扩展C#语法建立一个ThreadStart委托：2.1_ThreadStart

 1 class ThreadTest
 2 {
 3     static void Main()
 4     {
 5         Thread t = new Thread(new ThreadStart(Go));
 6         t.Start(); 
 7         Go();
 8         Console.ReadKey();
 9     }
10     static void Go()
11     {
12         Console.WriteLine("hello!");
13     }
14 }

在这个例子中，thread t执行Go(),基本上与主线同时程调用Go()方法，结果是打印出两个时间接近的hello。

一个线程能够被方便的建立经过指定一个方法组，而后由C#推断出ThreadStart委托：2.2_Thread

 1 class Program
 2 {
 3     static void Main(string[] args)
 4     {
 5         Thread t = new Thread(Go);
 6         t.Start();
 7         Go();
 8         Console.ReadKey();
 9     }
10 
11     static void Go()
12     {
13         Console.WriteLine("Go");
14     }
15 }

另一种更简单的方式是使用lambda表达式或者匿名方法：2.3_LambaExpression

static void Main(string[] args)
{
    Thread t = new Thread(()=>Console.WriteLine("Go"));
    t.Start();
    Console.ReadKey();
}

2、传递数据给一个线程

1.利用Lambda传递一个数据

传递参数给线程的目标方法的最简单的方法是执行一个lambda表达式，该表达式调用一个方法并传递指望的参数给这个方法。

2.4_PassingDataToAThread

static void Main(string[] args)
{
    Thread t = new Thread(() => Print("A"));
    t.Start();
    Console.ReadKey();
}

static void Print(string message)
{
    Console.WriteLine(message);
}

2.传递多个参数

经过这种方式，你能够传递任意数量的参数给这个方法。你甚至能够将整个实现包装在一个多语句的lambda中：

2.5_PassingDataToAThread

new Thread(() =>
{
    Console.WriteLine("a");
    Console.WriteLine("b");
}).Start();

你也能够简单的在C# 2.0里面那样使用匿名方法作一样的事：

new Thread(delegate()
{
    Console.WriteLine("a");
    Console.WriteLine("b");
}).Start();

3.利用Thread.Start传递参数

另一种方式是传递一个参数给Thread的Start方法：

2.6_PassingDataToAThread_ThreadStart

static void Main(string[] args)
{
    Thread t = new Thread(Print);
    t.Start("A");
    Console.ReadKey();
}
static void Print(object messageObj)
{
    string message = (string)messageObj;//必须进行转换
    Console.WriteLine(message);
}

这种方式可以工做是由于Thread的构造函数是重载的，接受下面两种中的任意一种委托：

// Summary:
//     Represents the method that executes on a System.Threading.Thread.
[ComVisible(true)]
public delegate void ThreadStart();

// Summary:
//     Represents the method that executes on a System.Threading.Thread.
//
// Parameters:
//   obj:
//     An object that contains data for the thread procedure.
[ComVisible(false)]
public delegate void ParameterizedThreadStart(object obj);

这个ParameterizedThreadStart的只容许接收一个参数。并且由于它的类型是object，因此一般须要转换。

4.Lambda表达式和捕获变量

由咱们上面看到的例子能够知道，一个lambda式在传递数据给线程是最用的。然而，你必须很是当心在开始线程后意外修改捕获变量，由于这些变量是共享的。好比下面的：

2.7_LbdaExpressionsAndCapturedVariables

for(int i =0;i<10;i++)
{
    new Thread(() => Console.Write(i)).Start();
}

这个输出是不肯定的，下面是一种典型的状况：

这里的问题是变量i在for循环执行时指向同一个内存地址。所以，每个线程调用Console.Write时，i的值有可能在这个线程运行时改变。

解决方案是使用一个临时变量：

2.8_LambdaExpressionsAndCapturedVariables_Solution

for (int i = 0; i < 10; i++)
{
    int temp = i;
    new Thread(() => Console.Write(temp)).Start();
}

变量temp在每一个循环迭代中位于不一样的内存块。所以每个线程捕获到了不一样的内存位置，并且没有问题。咱们能够解释在以前的代码中的问题：

2.9_PassingData_TemporaryVariable

string text = "A";
Thread a = new Thread(() => Console.WriteLine(text));

text = "B";
Thread b = new Thread(() => Console.WriteLine(text));

a.Start();
b.Start();

由于两个lambda表达式捕获一样的text的值，因此B被打印出两次。

3、命名线程

每个线程有一个Name属性你能够方便用来debugging.当线程显示在Visual Statudio里面的Threads Window和Debug Loaction toolbar的时候，线程的Name属性是特别有用的。你能够只设置线程的名字一次；以后尝试改变它将会抛出异常信息。

静态的Thread.CurrentThread属性表明当前执行的线程。

在下面的例子2.10_NamingThread中，咱们设置了主线程的名字：

static void Main(string[] args)
{
    Thread.CurrentThread.Name = "Main Thread";
    Thread t = new Thread(Go);
    t.Name = "Worker Thread";
    t.Start();
    Go();
    Console.ReadKey();
}
static void Go()
{
    Console.WriteLine("Go! The current thread is {0}", Thread.CurrentThread.Name);
}

4、前台线程和后台线程

默认状况下，你本身显示建立的线程是前台线程。前台线程保持这个应用程序一直存活只要其中任意一个正在运行，然后台线程不是这样的。一旦全部的前台线程完成，这个应用程序就结束了， 任何正在运行的后台线程马上终止。

一个线程前台/后台的状态跟它的优先级和配置的执行时间没有关联。

你可使用线程的IsBackgroud属性查询或改变一个线程的后台状态。

下面是例子：2.11_PriorityTest

static void Main(string[] args)
{
    Thread t = new Thread(() => Console.ReadKey());
    if (args.Length > 0)//若是Main方法没有传入参数
    {
        //设置线程为后台线程，等待用户输入。
        //由于主线程在t.Start()执行以后就会终止，
        //因此后台线程t会在主线程退出以后，当即终止，应用程序就会结束。
        t.IsBackground = true;
    }
    t.Start();
}

若是程序调用的时候传入了参数，则建立的线程为前台线程，而后等待用户输入。

同时，若是主线程退出，应用程序将不会退出，由于前台线程t没有退出。

另外一方面，若是main方法传入了参数，则建立的线程设置为后台线程。当主线程退出时，应用程序当即退出。

当一个进程以这种方式终止，则任何后台线程执行栈里面的finally 语句块将会被规避。

若是你的线程使用finally(or using)语句块去执行如释放资源或者删除临时文件的清理工做，这将是一个问题。为了不这个，你能够显示地等待后台线程退出应用程序。

这里有两种实现方式：

  1. 若是你本身建立了这个线程，能够在这个线程上调用Join方法。
  2. 若是你使用线程池，可使用一个事件去等待处理这个线程。

在这两种状况下，你须要指定一个timeout，所以能够结束一个因为某些缘由拒绝完成的线程。这是你的备选退出策略：在最后，你想要你的应用程序关闭，不须要用户从任务管理器中删除。

若是用户使用任务管理器强制结束一个.NET进程，全部的线程像是后台线程同样终止。这个是观察到的行为，因此会由于CLR和操做系统的版本而不一样。

前台线程不须要这样对待，可是你必须当心避免可能形成线程不能结束的bugs。形成应用程序不能正确地退出的一个一般的缘由是有激活的前台线程还存活在。

5、线程优先级

一个线程的优先级决定了在操做系统中它能够获得多少相对其余线程的执行时间，下面是线程优先级的等级：

// Summary:
//     Specifies the scheduling priority of a System.Threading.Thread.
[Serializable]
[ComVisible(true)]
public enum ThreadPriority
{
    Lowest = 0,
    BelowNormal = 1,
    Normal = 2,
    AboveNormal = 3,
    Highest = 4,
}

当多线程同时是激活的，线程优先级是很重要的。

注意：提升线程优先级时，须要很是当心，这将可能致使其余线程对资源访问的饥饿状态的问题。

当提高一个线程的优先级时，不会使它执行实时工做，由于它被应用程序的进程优先级限制了。为了执行实时工做，你也必须经过使用System.Diagnostices的Process类来提高进程的优先级：

using (Process p = Process.GetCurrentProcess())
{
    p.PriorityClass = ProcessPriorityClass.High;
}

ProcessPriorityClass.High事实上是优先级最高的一档：实时。设置一个进程优先级到实时状态将会致使其余线程没法得到CPU时间片。若是你的应用程序意外地进入一个无限循环的状态，你甚至会发现操做被锁住了，只有电源键可以拯救你了。针对这个缘由，High一般对于实时应用程序是最好的选择。

若是你的实时应用程序有一个用户界面，提升程序的优先级将会使刷新界面占用昂贵的CPU的时间，且会使整个系统变得运行缓慢（尤为是UI很复杂的时候）。下降主线程优先级且提高进程的优先级来确保实时线程不会被界面重绘所抢占，可是不会解决其余进程对CPU访问缺少的问题，由于操做系统总体上会一直分配不成比例的资源给进程。一个理想的解决方案是让实时线程和用户界面用不一样的优先级运行在不一样的进程中，经过远程和内存映射文件来通讯。即便提升了进程优先级，在托管环境中处理硬实时系统需求仍是对适用性有限制。此外，潜藏的问题会被自动垃圾回收引进，操做系统会遇到新的挑战，即便是非托管代码，使用专用硬件或者特殊的实时平台，那将被最好的解决。

6、异常处理

在任何try/catch/finally 语句块做用域内建立的线程，当这个线程开始时，这个线程和语句块是没有关联的。

思考下面的程序：

 参考例子：2.12_ExceptionHandling

static void Main(string[] args)
{
    try
    {
        new Thread(Go).Start();
    }
    catch(Exception ex)
    {
        Console.WriteLine("Exception");
    }
    Console.ReadKey();
}
static void Go()
{
    throw null;
}

try/catch 声明在这个例子中是无效的，并且新建立的线程将会被一个未处理的NullReferenceException所阻断。当你考虑每个线程有一个单独的执行路径这种行为是说得通的。

改进方法是将exception handler移到Go()的方法中：

参考例子：2.13_ExceptionHandling_Remedy

class Program
{
    static void Main(string[] args)
    {
        new Thread(Go).Start();
        Console.ReadKey();
    }

    static void Go()
    {
        try
        {
            throw null;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

你须要在应用程序中的全部线程入口方法中添加一个exception handler ，就像你在主线程中作的那样。一个未处理的线程会形成整个应用程序关闭，并且会弹出一个很差看的窗口。

在写这个exception handling 语句块时，你可能极少忽略这个问题，典型状况是，你可能会记录exception的详细信息，而后可能显示一个窗口让用户去自动去提交这些信息到你的web server上。而后你可能会关掉这个应用程序-由于这个error毁坏了程序的状态。而后，这样作的开销是用户可能会丢失他最近的工做，好比打开的文档。

对于WPF和WinForm应用程序来讲，全局的exception handling 事件（Application.DispatcherUnhandlerException 和Application.ThreadException）只会检测到主UI线程上的抛出的异常。你仍是必须手动处理线程的异常。

AppDomain.CurrentDomain.UnhandledException能够检测任何未处理的异常，可是没法阻止应用程序以后关闭。

然而，某些情形下你不须要在线程上处理异常，由于.NET Framework为你作了这个。下面是没有说起的内容：

Asynchronous delegates

BackgroudWorker

The Task Parallel Library(conditions apply)

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程