C#多线程编程系列（二）- 线程基础

2018-08-09 714

C#多线程编程系列（二）- 线程基础

1.1 简介

线程基础主要包括线程创建、挂起、等待和终止线程。关于更多的线程的底层实现，CPU时间片轮转等等的知识，可以参考《深入理解计算机系统》一书中关于进程和线程的章节，本文不过多赘述。

1.2 创建线程

在C#语言中，创建线程是一件非常简单的事情；它只需要用到 System.Threading命名空间，其中主要使用Thread类来创建线程。

演示代码如下所示：

using System;
using System.Threading; // 创建线程需要用到的命名空间
namespace Recipe1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1.创建一个线程 PrintNumbers为该线程所需要执行的方法
            Thread t = new Thread(PrintNumbers);
            // 2.启动线程
            t.Start();

            // 主线程也运行PrintNumbers方法，方便对照
            PrintNumbers();
            // 暂停一下
            Console.ReadKey();
        }

        static void PrintNumbers()
        {
            // 使用Thread.CurrentThread.ManagedThreadId 可以获取当前运行线程的唯一标识，通过它来区别线程
            Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印...");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i}");
            }
        }
    }
}

运行结果如下图所示，我们可以通过运行结果得知上面的代码创建了一个线程，然后主线程和创建的线程交叉输出结果，这说明PrintNumbers方法同时运行在主线程和另外一个线程中。

1.3 暂停线程

暂停线程这里使用的方式是通过Thread.Sleep方法，如果线程执行Thread.Sleep方法，那么操作系统将在指定的时间内不为该线程分配任何时间片。如果Sleep时间100ms那么操作系统将至少让该线程睡眠100ms或者更长时间，所以Thread.Sleep方法不能作为高精度的计时器使用。

演示代码如下所示：

using System;
using System.Threading; // 创建线程需要用到的命名空间
namespace Recipe2
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1.创建一个线程 PrintNumbers为该线程所需要执行的方法
            Thread t = new Thread(PrintNumbersWithDelay);
            // 2.启动线程
            t.Start();

            // 暂停一下
            Console.ReadKey();
        }

        static void PrintNumbersWithDelay()
        {
            Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印... 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}");
            for (int i = 0; i < 10; i++)
            {
                //3. 使用Thread.Sleep方法来使当前线程睡眠，TimeSpan.FromSeconds(2)表示时间为 2秒
                Thread.Sleep(TimeSpan.FromSeconds(2));
                Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i} 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}");
            }
        }
    }
}

运行结果如下图所示，通过下图可以确定上面的代码是有效的，通过Thread.Sleep方法，使线程休眠了2秒左右，但是并不是特别精确的2秒。验证了上面的说法，它的睡眠是至少让线程睡眠多长时间，而不是一定多长时间。

1.4 线程等待

在本章中，线程等待使用的是Join方法，该方法将暂停执行当前线程，直到所等待的另一个线程终止。在简单的线程同步中会使用到，但它比较简单，不作过多介绍。

演示代码如下所示：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine($"-------开始执行 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------");

        // 1.创建一个线程 PrintNumbersWithDelay为该线程所需要执行的方法
        Thread t = new Thread(PrintNumbersWithDelay);
        // 2.启动线程
        t.Start();
        // 3.等待线程结束
        t.Join();

        Console.WriteLine($"-------执行完毕 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------");
        // 暂停一下
        Console.ReadKey();
    }

    static void PrintNumbersWithDelay()
    {
        Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印... 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}");
        for (int i = 0; i < 10; i++)
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i} 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}");
        }
    }
}

运行结果如下图所示，开始执行和执行完毕两条信息由主线程打印；根据其输出的顺序可见主线程是等待另外的线程结束后才输出执行完毕这条信息。

1.5 终止线程

终止线程使用的方法是Abort方法，当该方法被执行时，将尝试销毁该线程。通过引发ThreadAbortException异常使线程被销毁。但一般不推荐使用该方法，原因有以下几点。

使用Abort方法只是尝试销毁该线程，但不一定能终止线程。

如果被终止的线程在执行lock内的代码，那么终止线程会造成线程不安全。

线程终止时，CLR会保证自己内部的数据结构不会损坏，但是BCL不能保证。

基于以上原因不推荐使用Abort方法，在实际项目中一般使用CancellationToken来终止线程。

演示代码如下所示：

static void Main(string[] args)
{
    Console.WriteLine($"-------开始执行 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------");

    // 1.创建一个线程 PrintNumbersWithDelay为该线程所需要执行的方法
    Thread t = new Thread(PrintNumbersWithDelay);
    // 2.启动线程
    t.Start();
    // 3.主线程休眠6秒
    Thread.Sleep(TimeSpan.FromSeconds(6));
    // 4.终止线程
    t.Abort();

    Console.WriteLine($"-------执行完毕 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------");
    // 暂停一下
    Console.ReadKey();
}

static void PrintNumbersWithDelay()
{
    Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印... 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}");
    for (int i = 0; i < 10; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(2));
        Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i} 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}");
    }
}

运行结果如下图所示，启动所创建的线程3后，6秒钟主线程调用了Abort方法，线程3没有继续执行便结束了；与预期的结果一致。

1.6 检测线程状态

线程的状态可通过访问ThreadState属性来检测，ThreadState是一个枚举类型，一共有10种状态，状态具体含义如下表所示。

成员名称	说明
Aborted	线程处于 Stopped 状态中。
AbortRequested	已对线程调用了 Thread.Abort 方法，但线程尚未收到试图终止它的挂起的 System.Threading.ThreadAbortException。
Background	线程正作为后台线程执行（相对于前台线程而言）。此状态可以通过设置 Thread.IsBackground 属性来控制。
Running	线程已启动，它未被阻塞，并且没有挂起的 ThreadAbortException。
Stopped	线程已停止。
StopRequested	正在请求线程停止。这仅用于内部。
Suspended	线程已挂起。
SuspendRequested	正在请求线程挂起。
Unstarted	尚未对线程调用 Thread.Start 方法。
WaitSleepJoin	由于调用 Wait、Sleep 或 Join，线程已被阻止。

下表列出导致状态更改的操作。

操作	ThreadState
在公共语言运行库中创建线程。	Unstarted
线程调用 Start	Unstarted
线程开始运行。	Running
线程调用 Sleep	WaitSleepJoin
线程对其他对象调用 Wait。	WaitSleepJoin
线程对其他线程调用 Join。	WaitSleepJoin
另一个线程调用 Interrupt	Running
另一个线程调用 Suspend	SuspendRequested
线程响应 Suspend 请求。	Suspended
另一个线程调用 Resume	Running
另一个线程调用 Abort	AbortRequested
线程响应 Abort 请求。	Stopped
线程被终止。	Stopped

演示代码如下所示：

static void Main(string[] args)
{
    Console.WriteLine("开始执行...");

    Thread t = new Thread(PrintNumbersWithStatus);
    Thread t2 = new Thread(DoNothing);

    // 使用ThreadState查看线程状态 此时线程未启动，应为Unstarted
    Console.WriteLine($"Check 1 :{t.ThreadState}");

    t2.Start();
    t.Start();

    // 线程启动， 状态应为 Running
    Console.WriteLine($"Check 2 :{t.ThreadState}");

    // 由于PrintNumberWithStatus方法开始执行，状态为Running
    // 但是经接着会执行Thread.Sleep方法 状态会转为 WaitSleepJoin
    for (int i = 1; i < 30; i++)
    {
        Console.WriteLine($"Check 3 : {t.ThreadState}");
    }

    // 延时一段时间，方便查看状态
    Thread.Sleep(TimeSpan.FromSeconds(6));

    // 终止线程
    t.Abort();

    Console.WriteLine("t线程被终止");

    // 由于该线程是被Abort方法终止 所以状态为 Aborted或AbortRequested
    Console.WriteLine($"Check 4 : {t.ThreadState}");
    // 该线程正常执行结束 所以状态为Stopped
    Console.WriteLine($"Check 5 : {t2.ThreadState}");

    Console.ReadKey();
}

static void DoNothing()
{
    Thread.Sleep(TimeSpan.FromSeconds(2));
}

static void PrintNumbersWithStatus()
{
    Console.WriteLine("t线程开始执行...");

    // 在线程内部，可通过Thread.CurrentThread拿到当前线程Thread对象
    Console.WriteLine($"Check 6 : {Thread.CurrentThread.ThreadState}");
    for (int i = 1; i < 10; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(2));
        Console.WriteLine($"t线程输出 ：{i}");
    }
}

运行结果如下图所示，与预期的结果一致。

1.7 线程优先级

Windows操作系统为抢占式多线程(Preemptive multithreaded)操作系统，是因为线程可在任何时间停止（被枪占）并调度另一个线程。

Windows操作系统中线程有0(最低) ~ 31(最高)的优先级，而优先级越高所能占用的CPU时间就越多，确定某个线程所处的优先级需要考虑进程优先级和相对线程优先级两个优先级。

进程优先级：Windows支持6个进程优先级，分别是Idle、Below Normal、Normal、Above normal、High 和Realtime。默认为Normal。

相对线程优先级：相对线程优先级是相对于进程优先级的，因为进程包含了线程。Windows支持7个相对线程优先级，分别是Idle、Lowest、Below Normal、Normal、Above Normal、Highest 和 Time-Critical.默认为Normal。

下表总结了进程的优先级和线程的相对优先级与优先级(0~31)的映射关系。粗体为相对线程优先级，斜体为进程优先级。

	Idle	Below Normal	Normal	Above Normal	High	Realtime
Time-Critical	15	15	15	15	15	31
Highest	6	8	10	12	15	26
Above Normal	5	7	9	11	14	25
Normal	4	6	8	10	13	24
Below Normal	3	5	7	9	12	23
Lowest	2	4	6	8	11	22
Idle	1	1	1	1	1	16

而在C#程序中，可更改线程的相对优先级，需要设置Thread的Priority属性，可设置为ThreadPriority枚举类型的五个值之一：Lowest、BelowNormal、Normal、AboveNormal 或 Highest。CLR为自己保留了Idle和Time-Critical优先级，程序中不可设置。

演示代码如下所示。

static void Main(string[] args)
{
    Console.WriteLine($"当前线程优先级: {Thread.CurrentThread.Priority} \r\n");

    // 第一次测试，在所有核心上运行
    Console.WriteLine("运行在所有空闲的核心上");
    RunThreads();
    Thread.Sleep(TimeSpan.FromSeconds(2));

    // 第二次测试，在单个核心上运行
    Console.WriteLine("\r\n运行在单个核心上");
    // 设置在单个核心上运行
    System.Diagnostics.Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
    RunThreads();

    Console.ReadLine();
}

static void RunThreads()
{
    var sample = new ThreadSample();

    var threadOne = new Thread(sample.CountNumbers);
    threadOne.Name = "线程一";
    var threadTwo = new Thread(sample.CountNumbers);
    threadTwo.Name = "线程二";

    // 设置优先级和启动线程
    threadOne.Priority = ThreadPriority.Highest;
    threadTwo.Priority = ThreadPriority.Lowest;
    threadOne.Start();
    threadTwo.Start();

    // 延时2秒 查看结果
    Thread.Sleep(TimeSpan.FromSeconds(2));
    sample.Stop();
}

class ThreadSample
{
    private bool _isStopped = false;

    public void Stop()
    {
        _isStopped = true;
    }

    public void CountNumbers()
    {
        long counter = 0;

        while (!_isStopped)
        {
            counter++;
        }

        Console.WriteLine($"{Thread.CurrentThread.Name} 优先级为 {Thread.CurrentThread.Priority,11} 计数为 = {counter,13:N0}");
    }
}

运行结果如下图所示。Highest占用的CPU时间明显多于Lowest。当程序运行在所有核心上时，线程可以在不同核心同时运行，所以Highest和Lowest差距会小一些。

1.8 前台线程和后台线程

在CLR中，线程要么是前台线程，要么就是后台线程。当一个进程的所有前台线程停止运行时，CLR将强制终止仍在运行的任何后台线程，不会抛出异常。

在C#中可通过Thread类中的IsBackground属性来指定是否为后台线程。在线程生命周期中，任何时候都可从前台线程变为后台线程。线程池中的线程默认为后台线程。

演示代码如下所示。

static void Main(string[] args)
{
    var sampleForeground = new ThreadSample(10);
    var sampleBackground = new ThreadSample(20);
    var threadPoolBackground = new ThreadSample(20);

    // 默认创建为前台线程
    var threadOne = new Thread(sampleForeground.CountNumbers);
    threadOne.Name = "前台线程";

    var threadTwo = new Thread(sampleBackground.CountNumbers);
    threadTwo.Name = "后台线程";
    // 设置IsBackground属性为 true 表示后台线程
    threadTwo.IsBackground = true;

    // 线程池内的线程默认为 后台线程
    ThreadPool.QueueUserWorkItem((obj) => {
        Thread.CurrentThread.Name = "线程池线程";
        threadPoolBackground.CountNumbers();
    });

    // 启动线程 
    threadOne.Start();
    threadTwo.Start();
}

class ThreadSample
{
    private readonly int _iterations;

    public ThreadSample(int iterations)
    {
        _iterations = iterations;
    }
    public void CountNumbers()
    {
        for (int i = 0; i < _iterations; i++)
        {
            Thread.Sleep(TimeSpan.FromSeconds(0.5));
            Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
        }
    }
}

运行结果如下图所示。当前台线程10次循环结束以后，创建的后台线程和线程池线程都会被CLR强制结束。

1.9 向线程传递参数

向线程中传递参数常用的有三种方法，构造函数传值、Start方法传值和Lambda表达式传值，一般常用Start方法来传值。

演示代码如下所示，通过三种方式来传递参数，告诉线程中的循环最终需要循环几次。

static void Main(string[] args)
{
    // 第一种方法 通过构造函数传值
    var sample = new ThreadSample(10);

    var threadOne = new Thread(sample.CountNumbers);
    threadOne.Name = "ThreadOne";
    threadOne.Start();
    threadOne.Join();

    Console.WriteLine("--------------------------");

    // 第二种方法 使用Start方法传值 
    // Count方法 接收一个Object类型参数
    var threadTwo = new Thread(Count);
    threadTwo.Name = "ThreadTwo";
    // Start方法中传入的值 会传递到 Count方法 Object参数上
    threadTwo.Start(8);
    threadTwo.Join();

    Console.WriteLine("--------------------------");

    // 第三种方法 Lambda表达式传值
    // 实际上是构建了一个匿名函数 通过函数闭包来传值
    var threadThree = new Thread(() => CountNumbers(12));
    threadThree.Name = "ThreadThree";
    threadThree.Start();
    threadThree.Join();
    Console.WriteLine("--------------------------");

    // Lambda表达式传值 会共享变量值
    int i = 10;
    var threadFour = new Thread(() => PrintNumber(i));
    i = 20;
    var threadFive = new Thread(() => PrintNumber(i));
    threadFour.Start();
    threadFive.Start();
}

static void Count(object iterations)
{
    CountNumbers((int)iterations);
}

static void CountNumbers(int iterations)
{
    for (int i = 1; i <= iterations; i++)
    {
        Thread.Sleep(TimeSpan.FromSeconds(0.5));
        Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
    }
}

static void PrintNumber(int number)
{
    Console.WriteLine(number);
}

class ThreadSample
{
    private readonly int _iterations;

    public ThreadSample(int iterations)
    {
        _iterations = iterations;
    }
    public void CountNumbers()
    {
        for (int i = 1; i <= _iterations; i++)
        {
            Thread.Sleep(TimeSpan.FromSeconds(0.5));
            Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}");
        }
    }
}

运行结果如下图所示，与预期结果相符。

1.10 C# Lock关键字的使用

在多线程的系统中，由于CPU的时间片轮转等线程调度算法的使用，容易出现线程安全问题。具体可参考《深入理解计算机系统》一书相关的章节。

在C#中lock关键字是一个语法糖，它将Monitor封装，给object加上一个互斥锁，从而实现代码的线程安全，Monitor会在下一节中介绍。

对于lock关键字还是Monitor锁定的对象，都必须小心选择，不恰当的选择可能会造成严重的性能问题甚至发生死锁。以下有几条关于选择锁定对象的建议。

同步锁定的对象不能是值类型。因为使用值类型时会有装箱的问题，装箱后的就成了一个新的实例，会导致Monitor.Enter()和Monitor.Exit()接收到不同的实例而失去关联性

避免锁定this、typeof(type)和string。this和typeof(type)锁定可能在其它不相干的代码中会有相同的定义，导致多个同步块互相阻塞。string需要考虑字符串拘留的问题，如果同一个字符串常量在多个地方出现，可能引用的会是同一个实例。

对象的选择作用域尽可能刚好达到要求，使用静态的、私有的变量。

以下演示代码实现了多线程情况下的计数功能，一种实现是线程不安全的，会导致结果与预期不相符，但也有可能正确。另外一种使用了lock关键字进行线程同步，所以它结果是一定的。

static void Main(string[] args)
{
    Console.WriteLine("错误的多线程计数方式");

    var c = new Counter();
    // 开启3个线程，使用没有同步块的计数方式对其进行计数
    var t1 = new Thread(() => TestCounter(c));
    var t2 = new Thread(() => TestCounter(c));
    var t3 = new Thread(() => TestCounter(c));
    t1.Start();
    t2.Start();
    t3.Start();
    t1.Join();
    t2.Join();
    t3.Join();

    // 因为多线程 线程抢占等原因 其结果是不一定的  碰巧可能为0
    Console.WriteLine($"Total count: {c.Count}");
    Console.WriteLine("--------------------------");

    Console.WriteLine("正确的多线程计数方式");

    var c1 = new CounterWithLock();
    // 开启3个线程，使用带有lock同步块的方式对其进行计数
    t1 = new Thread(() => TestCounter(c1));
    t2 = new Thread(() => TestCounter(c1));
    t3 = new Thread(() => TestCounter(c1));
    t1.Start();
    t2.Start();
    t3.Start();
    t1.Join();
    t2.Join();
    t3.Join();

    // 其结果是一定的 为0
    Console.WriteLine($"Total count: {c1.Count}");

    Console.ReadLine();
}

static void TestCounter(CounterBase c)
{
    for (int i = 0; i < 100000; i++)
    {
        c.Increment();
        c.Decrement();
    }
}

// 线程不安全的计数
class Counter : CounterBase
{
    public int Count { get; private set; }

    public override void Increment()
    {
        Count++;
    }

    public override void Decrement()
    {
        Count--;
    }
}

// 线程安全的计数
class CounterWithLock : CounterBase
{
    private readonly object _syncRoot = new Object();

    public int Count { get; private set; }

    public override void Increment()
    {
        // 使用Lock关键字 锁定私有变量
        lock (_syncRoot)
        {
            // 同步块
            Count++;
        }
    }

    public override void Decrement()
    {
        lock (_syncRoot)
        {
            Count--;
        }
    }
}

abstract class CounterBase
{
    public abstract void Increment();

    public abstract void Decrement();
}

运行结果如下图所示，与预期结果相符。

1.11 使用Monitor类锁定资源

Monitor类主要用于线程同步中， lock关键字是对Monitor类的一个封装，其封装结构如下代码所示。

try
{
    Monitor.Enter(obj);
    dosomething();
}
catch(Exception ex)
{  
}
finally
{
    Monitor.Exit(obj);
}

以下代码演示了使用Monitor.TyeEnter()方法避免资源死锁和使用lock发生资源死锁的场景。

        static void Main(string[] args)
        {
            object lock1 = new object();
            object lock2 = new object();

            new Thread(() => LockTooMuch(lock1, lock2)).Start();

            lock (lock2)
            {
                Thread.Sleep(1000);
                Console.WriteLine("Monitor.TryEnter可以不被阻塞, 在超过指定时间后返回false");
                // 如果5S不能进入同步块，那么返回。
                // 因为前面的lock锁定了 lock2变量  而LockTooMuch()一开始锁定了lock1 所以这个同步块无法获取 lock1 而LockTooMuch方法内也不能获取lock2
                // 只能等待TryEnter超时 释放 lock2 LockTooMuch()才会是释放 lock1
                if (Monitor.TryEnter(lock1, TimeSpan.FromSeconds(5)))
                {
                    Console.WriteLine("获取保护资源成功");
                }
                else
                {
                    Console.WriteLine("获取资源超时");
                }
            }

            new Thread(() => LockTooMuch(lock1, lock2)).Start();

            Console.WriteLine("----------------------------------");
            lock (lock2)
            {
                Console.WriteLine("这里会发生资源死锁");
                Thread.Sleep(1000);
                // 这里必然会发生死锁  
                // 本同步块 锁定了 lock2 无法得到 lock1
                // 而 LockTooMuch 锁定了 lock1 无法得到 lock2
                lock (lock1)
                {
                    // 该语句永远都不会执行
                    Console.WriteLine("获取保护资源成功");
                }
            }
        }

        static void LockTooMuch(object lock1, object lock2)
        {
            lock (lock1)
            {
                Thread.Sleep(1000);
                lock (lock2) ;
            }
        }

运行结果如下图所示，因为使用Monitor.TryEnter()方法在超时以后会返回，不会阻塞线程，所以没有发生死锁。而第二段代码中lock没有超时返回的功能，导致资源死锁，同步块中的代码永远不会被执行。

1.12 多线程中处理异常

在多线程中处理异常应当使用就近原则，在哪个线程发生异常那么所在的代码块一定要有相应的异常处理。否则可能会导致程序崩溃、数据丢失。

主线程中使用try/catch语句是不能捕获创建线程中的异常。但是万一遇到不可预料的异常，可通过监听AppDomain.CurrentDomain.UnhandledException事件来进行捕获和异常处理。

演示代码如下所示，异常处理 1 和异常处理 2 能正常被执行，而异常处理 3 是无效的。

static void Main(string[] args)
{
    // 启动线程，线程代码中进行异常处理
    var t = new Thread(FaultyThread);
    t.Start();
    t.Join();

    // 捕获全局异常
    AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
    t = new Thread(BadFaultyThread);
    t.Start();
    t.Join();

    // 线程代码中不进行异常处理，尝试在主线程中捕获
    AppDomain.CurrentDomain.UnhandledException -= CurrentDomain_UnhandledException;
    try
    {
        t = new Thread(BadFaultyThread);
        t.Start();
    }
    catch (Exception ex)
    {
        // 永远不会运行
        Console.WriteLine($"异常处理 3 : {ex.Message}");
    }
}

private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
    Console.WriteLine($"异常处理 2 ：{(e.ExceptionObject as Exception).Message}");
}

static void BadFaultyThread()
{
    Console.WriteLine("有异常的线程已启动...");
    Thread.Sleep(TimeSpan.FromSeconds(2));
    throw new Exception("Boom!");
}

static void FaultyThread()
{
    try
    {
        Console.WriteLine("有异常的线程已启动...");
        Thread.Sleep(TimeSpan.FromSeconds(1));
        throw new Exception("Boom!");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"异常处理 1 : {ex.Message}");
    }
}

运行结果如下图所示，与预期结果一致。

参考书籍

本文主要参考了以下几本书，在此对这些作者表示由衷的感谢你们提供了这么好的资料。

《CLR via C#》

《C# in Depth Third Edition》

《Essential C# 6.0》

《Multithreading with C# Cookbook Second Edition》

线程基础这一章节终于整理完了，是笔者学习过程中的笔记和思考。计划按照《Multithreading with C# Cookbook Second Edition》这本书的结构，一共更新十二个章节，先立个Flag。

源码下载点击链接 示例源码下载

笔者水平有限，如果错误欢迎各位批评指正！

微信关注我们

原文链接：https://yq.aliyun.com/articles/677907

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

C#多线程编程系列（一）- 简介

原文: C#多线程编程系列（一）- 简介目录系列大纲一、前言二、目录结构四、章节结构五、相关链接系列大纲目前只整理到第二章，线程同步，笔者后面会慢慢更新，争取能把这本书中精华的知识都分享出来。C#多线程编程系列（一）- 简介C#多线程编程系列（二）- 线程基础C#多线程编程系列（三）- 线程同步C#多线程编程系列（四）- 使用线程池C#多线程编程系列（五）- 使用任务并行库源码下载点击链接示例源码下载一、前言在C#学习过程中，多线程一直都是比较难的部分，因为其中涉及到很多与操作系统相关的知识。比如：如何进行多线程编程、线程同步、线程锁、线程异步、并行编程、并行集合等等的知识。所以笔者在学习过程中也是遇到了重重困难，而且一直没有好的教程。但是笔者在浏览GitHub时，发现有大佬已经推荐了一本新书，《MULTITHREADING WITH C# COOKBOOK SECOND EDITION》,其中主要就是讲如何在C#中使用多线程的。看到这本书笔者是如获珍宝，终于能有机会系统的学习多线程相关的知识了。于是便有了这一个开篇，这个更多的是阅读这本书的笔记和一些按照书...

2018-08-10

1843

原文: C#多线程编程系列（三）- 线程同步目录 1.1 简介 1.2 执行基本原子操作 1.3 使用Mutex类 1.4 使用SemaphoreSlim类 1.5 使用AutoResetEvent类 1.6 使用ManualResetEventSlim类 1.7 使用CountDownEvent类 1.8 使用Barrier类 1.9 使用ReaderWriterLockSlim类 1.10 使用SpinWait类参考书籍笔者水平有限，如果错误欢迎各位批评指正！ 1.1 简介本章介绍在C#中实现线程同步的几种方法。因为多个线程同时访问共享数据时，可能会造成共享数据的损坏，从而导致与预期的结果不相符。为了解决这个问题，所以需要用到线程同步，也被俗称为“加锁”。但是加锁绝对不对提高性能，最多也就是不增不减，要实现性能不增不减还得靠高质量的同步源语(Synchronization Primitive)。但是因为正确永远比速度更重要，所以线程同步在某些场景下是必须的。线程同步有两种源语(Primitive)构造：用户模式(user - mode)和内核模式(kernel - mod...

2018-08-10

664

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。