14.并发与异步 - 1.线程处理Thread -《果壳中的c#》

时间:2022-11-19 22:58:56

14.并发与异步 - 1.线程处理Thread -《果壳中的c#》

14.2.1 创建一个线程

实例化一个Thread对象,然后调用它的Start方法,就可以创建和启动一个新的线程。最简单的Thread构造方法是接受一个ThreadStart代理:一个无参方法,表示执行开始位置。

//System.Threading.ThreadStart 委托,它表示此线程开始执行时要调用的方法
public Thread(ThreadStart start);

示例:

        static void Main(string[] args)
{
Thread t = new Thread(WriteY); //创建一个新线程
t.Start(); //启动线程 WriteY
//同时,主线程也会执行。
for (int i = 0; i < 1000; i++) Console.Write("x");
Console.Read();
} static void WriteY()
{
for (int i = 0; i < 1000; i++) Console.Write("y");
}

14.并发与异步 - 1.线程处理Thread -《果壳中的c#》

  1. 线程启动后,IsAlive属性变为True,直到线程停止。
  2. Thread的构造函数接收的代理执行完毕,线程会停止。
  3. 停止后,线程无法再启动。

每个线程都有一个Name属性,可用于调试。只能设置一次,修改线程名称会抛出异常。

静态属性Thread.CurrentThread可以返回当前执行的线程:

Console.Write(Thread.CurrentThread.Name);

14.2.2 联合与休眠

等待另一个线程结束时,可以调用另一个现成的Join方法:

        static void Main(string[] args)
{
Thread t = new Thread(Go);
t.Start();
t.Join();
Console.WriteLine("线程 t 已经结束");
Console.Read();
}
static void Go() { for (int i = 0; i < 1000; i++) Console.Write("y"); }

14.并发与异步 - 1.线程处理Thread -《果壳中的c#》

打印1000次“y”,然后再接着打印“线程 t 已经结束”。调用Join时,可以指定一个超时时间。然后,它会在线程结束时返回true,或者超时时返回false。

Thread.Sleep(TimeSpan.FromHours(1));//休眠1小时

调用Thread.Sleep(0),会马上放弃线程当前时间片,自动将CPU交给其他线程。Thread.Yield()方法也有相同的效果,但是它只会将资源交给同一处理器上运行的线程。

14.2.3 阻塞

线程阻塞是指线程由于特定原因暂停执行,如Sleeping或执行Join后等待另一个线程停止。阻塞的线程会立刻交出(yield)它的处理器时间片,然后从这时开始不再消耗处理器时间,直至阻塞条件结束。使用线程的ThreadState属性,可以测试线程的阻塞状态:

1.I/O密集与计算密集

如果一个操作将大部分时间用于等待一个条件的发生,那么就称为I/O密集(I/O-bound)操作。

相反,如果一个操作将大部分时间用于执行CPU秘籍操作,那么就称为计算密集(compute-bound)操作。

2.阻塞与自旋

I/O密集操作可以以两种方式执行:

同步等待当前线程的操作完成(如Console.ReadLine、Thread.Sleep或Thread.Join),或者异步执行,然后在将来操作完成时触发一个回调函数。

异步等待的I/O密集操作会将大部分时间花费在线程阻塞上。它们可能在一个定期循环中自旋:

while(DateTime < nextStartTime)
Thread.Sleep(100);

14.2.4 本地状态与共享状态

CLR会给每一个线程分配独立的内存堆,从而保证本地变量的隔离。下例定义一个方法,其中包含一个局部(本地)变量,然后同时在主线程和新创建的线程上调用这个方法:

        static void Main(string[] args)
{
new Thread(Go).Start(); //在 新线程 上调用GO
Go(); //在 主线程 调用GO
Console.Read();
} static void Go()
{
for (int cycles = 0; cycles < 5; cycles++)
{
Console.Write('?');
}
}

每一个线程的内存堆会创建cycles变量副本,所以输出结果为10个问号。

如果线程拥有一个对象实例的通用引用,那么这些线程就共享相同的数据:

class ThreadTest
{
bool _done;
static void Main(string[] args)
{
ThreadTest tt = new ThreadTest();
new Thread(tt.GO).Start();
tt.GO();
Console.Read();
} void GO()
{
if (!_done)
{
_done = true;
Console.WriteLine("Done");
}
}
}

因为这两个线程都在同一个ThreadTest实例上调用GO(),所以它们共享_done域。因此,“Done”只会打印一次,而不会打印两次。

其它方式:

编译器会将Lambda表达式或匿名代理捕获的局部变量转为域,所以它们也可以共享。

静态域是在线程之间共享数据的另一种方法。

14.2.5 锁与线程安全

    class ThreadSafe
{
static bool _done;
static readonly object _locker = new object();
static void Main(string[] args)
{
new Thread(Go).Start();
Go();
Console.Read();
} static void Go()
{
lock (_locker)
{
if (_done)
{
Console.WriteLine("Done");
_done = true;
}
}
}
}

结果:(什么都没有)

当两个线程同时争夺一个锁时(它可以是任意引用类型的对象,这里是_locker),其中一个线程会等待(或阻塞),直到锁释放。这个例子保证一次只会一个线程进入它的代码块,因此“Done”只会打印一次。

在复杂多线程环境中,采用这种方式来保护代码就是具有线程安全性。

锁并不是解决线程安全的万能法宝 —— 人们很容易在访问域时忘记锁,而且锁本身也存在一些问题(如死锁)。

14.2.6 传递数据到线程

给线程启动方法传递一些参数。最简单是使用Lambda表达式,然后用指定参数调用这个方法:

        static void Main()
{
Thread t = new Thread(() => Print("Hello from t!"));
t.Start();
} static void Print(string message) { Console.WriteLine(message); }

这种方法可以给这个方法传递任意数量的参数。甚至可以将整个实现过程封装在一个多语句Lambda表达式中

new Thread (() =>
{
Console.WriteLine ("I'm running on another thread!");
Console.WriteLine ("This is so easy!");
}).Start()

Lambda表达式与捕获的变量

在线程启动之后,一定要注意小心修改捕捉的变量。

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

这段代码输出结果不确定,下面是一种常见的:

14.并发与异步 - 1.线程处理Thread -《果壳中的c#》

问题是,在整个循环过程中,变量i都指向同一块内存地址。因此,每次线程调用Console.Write处理变量时,这个变量的值可能发生了变化!解决方法是使用临时变量:

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

变量temp是每个循环过程的局部变量,因此,每一个线程都会获取完全不同的内存地址。

            String text = "t1";
Thread t1 = new Thread(()=>Console.WriteLine(text));
text = "t2";
Thread t2 = new Thread(() => Console.WriteLine(text));
t1.Start();t2.Start();

结果:t2 t2

由于两个Lambda表达式补货同一个text变量,所以t2会打印两次。

14.2.7 异常处理

线程创建时任何生效的try/catch/finally语句块在线程执行后都与线程无关

        static void Main(string[] args)
{
try
{
new Thread(Go).Start();
}
catch (Exception)
{
//代码永远不会运行到这里
Console.WriteLine("exception");
}
} static void Go() { throw null; } //抛出异常

解决方法 是将异常处理移动到Go方法内:

        static void Main(string[] args)
{
new Thread(Go).Start();
} static void Go()
{
//throw null;
try
{
throw null;//下面补货到异常 NullReferemceException
}
catch (Exception ex)
{
//通常是记录异常,并且/或者发信号给另一个线程,告诉它们捕捉到了异常
Console.WriteLine("exception");
}
}

结果: exception

集中式异常处理

WPF、Metro和Windows窗体应用程序都支持订阅全局异常处理事件,分别是Application.DispatcherUnhandledExceptionApplication.ThreadException。如果通过消息循环调用的程序中出现未处理异常(相当于Application激活时运行在主线程上的所有代码)。就会触发这些异常。这非常适合记录日志和报告缺陷(但是它不会触发非UI线程的未处理异常)。处理这些事件可防止程序意外关闭,但必须选择重启应用。

AppDomain.CurrentDomain.UnhandledException可以触发任意线程的任意未处理异常,CLR 2.0开始会在事件执行完后关闭应用程序。在程序配置文件中添加下面代码,可防止应用程序关闭:

<configuration>
<runtime>
<legacyUnhandledExceptionPolicy enabled="1" />
</runtime>
</configuration>

14.2.8 前台线程与后台线程

默认显示创建的线程为前台线程,使用线程的IsBackground属性。

前台线程:只有所有的前台线程都关闭才能完成程序关闭。(主线程一直是前台线程)

后台线程:只要所有的前台线程都结束,后台线程自动结束(CLR会强制结束所有仍运行的后台线程,却不会抛出异常)。

14.2.9 线程优先级

线程的Priority属性可以确定它与其他激活线程的相对执行时间长短,

		public enum ThreadPriority
{
Lowest = 0,
BelowNormal = 1,
Normal = 2,
AboveNormal = 3,
Highest = 4,
}

如果希望一个线程拥有比其他进程的线程更高的优先级,还必须使用System.DiagnosticsProcess类,提高进程本身优先级:

		worker.Priority = ThreadPriority.Highest;
//进程
using (Process p = Process.GetCurrentProcess())
{
p.PriorityClass = ProcessPriorityClass.High;
}

14.2.10 发送信号

有时候,一个线程需要等待其他线程的通知,这就是发送信号(signaling)。最简单的发送信号结构是ManualResetEvent。在一个ManualResetEvent上调用WaitOne,可以阻塞当前线程,使之一直等待另一个线程通过调用Set“打开”信号。

下面例子启动一个线程,等待ManualResetEvent到达,它会保持阻塞2秒钟,直至主线程发送信号:

        static void Main(string[] args)
{
//通知一个或多个正在等待的线程已发生事件,如果为 true,则将初始状态设置为终止
var signal = new ManualResetEvent(false);
new Thread(() =>
{
Console.WriteLine("等待 signal..");
signal.WaitOne(); //阻止当前线程,直到当前 System.Threading.WaitHandle 收到信号
signal.Dispose(); //释放由 System.Threading.WaitHandle 类的当前实例使用的所有资源。
Console.WriteLine("开始signal");
}).Start();
Thread.Sleep(2000);
signal.Set(); //打开信号 ---(将事件状态设置为终止状态,允许一个或多个等待线程继续) Console.Read();
}

调用Set后,信号仍然保持打开;调用Reset,就可以再次将它关闭。

14.2.12 同步上下文

System.ComponentModel 命名空间中有一个抽象类 SynchronizationContext。它实现了线程编列的一般化。

WPF、Metro和Windows窗体都定义和实例化了SynchronizationContext的子类,当运行在UI线程时,它通过静态属性SynchronizationContext.Current获得。

Framework2.0引入了BanckgroundWoker类,他使用SynchronizationContext类简化富客户端应用程序的工作者线程。

BanckgroundWoker 增加了相同的Tasks和异步功能,它也使用SynchronizationContext

14.2.13 线程池

无论何时启动一个线程,都需要一定时间(几百毫秒)用于创建新的局部变量堆。

线程池(thread pool)预先创建一组可回收线程,因此可以缩短这个过载时间。要实现高效的并行编程和细致的并发性,必须使用线程池。

考虑:

1. 由于不能设置池化线程的Name,因此会增加代码调试难度。

2. 池化线程通常都是后台线程。

3. 池化线程阻塞会影响性能。

1.进入线程池

在池化线程运行代码最简单的方法是使用Task.Run:

 Task.Run(() => Console.WriteLine("Hello from the thread pool"));

Framework 4.0之前不支持任务,所以改为调用ThreadPool.QueueUserWorkItem

ThreadPool.QueueUserWorkItem(notUsed => Console.WriteLine("Hello"));

2.线程池整洁性

线程池还有一个功能,既保证计算密集作业的临时过载不会引起CPU超负荷。

CLR能将任务进行排序,并且控制任务启动数量,从而避免线程池超负荷。

阻塞是很很麻烦的,因为它会让CLR错误地人为它占用了大量CPU。CLR能检测并补偿(往池中注入更多线程),但这可能使线程池受到后续超负荷的影响。此外,这样会增加延迟,一位内CLR会限制注入新线程的速度,特别是应用程序生命周期的前期。

如果想提高CPU利用率,那么一定要报保证线程池整洁性。