NETCLRvia<5.1>
线程部分
线程基础
Windows为什么要支持线程
在单核单线程系统中有两个问题:1. 如果系统需要执行某些长时间任务或死循环,就没办法响应其他任何,造成系统“假死”;2.当系统重启或任务崩溃的时候所有的数据都丢失。
针对第一个问题:多线程解决,线程的职责是对CPU进行虚拟化。所有线程共享物理CPU,Windows在某个一个时刻只将一个线程分配给CPU,一个时刻称为时间片quantum,时间一到,Windows就进行上下文切换到另一个线程。
针对第二个问题:进程解决,每个进程都被赋予一个虚拟地址控件,一个进程中使用的代码和数据不能被另一个进程使用。
Windows只能调度线程, 不能调度进程。
线程开销
线程有以下几个要素:
- 线程内核对象(thread kernel object):这是一个数据结构,包含:1.线程描述;2.线程上下文:存储CPU寄存器数据的内存块,不同CPU架构大小不一样,X64大概1240字节。
- 线程环境块(thread environment block,TEB):存储线程环境相关的块:包括异常处理链首,线程本地数据以及GDI和OpenGL图形相关的数据,不同CPU架构大概都4KB。
- 用户模式栈(User-mode stack):存储局部变量和实参,方法返回时线程的线程的执行地址,这个结构占用内存最大为1M。
- 内核模式栈(kernel-mode stack):操作系统内核模式函数时,需要将用户模式栈的实参,局部变量和返回地址复制到内核模式栈,用户不能访问内核模式也就不能修改实参了。不同架构CPU内存不一样,X64为24KB
- DLL线程链接(attach)和分离(detach):在创建线程,会向进程中所有加载的非托管dll的DllMain方法传递一个DLL_THREAD_ATTACH标志。线程终止时也会向该方法传递一个DLL_THREAD_DETACH标志。
所有线程共享物理CPU,Windows在某个一个时刻只将一个线程分配给CPU,一个时刻称为时间片quantum(大概30ms,取决于CPU架构),时间一到,Windows就进行上下文切换到另一个线程。
上下文切换时Windows的操作:
- 将CPU寄存器中的值复制到线程内核对象的线程上下文结构中。
- 在现有线程集合中调度一个线程执行,如果该线程在另一个进程中,就切换进程的虚拟空间地址。
- 将选中线程的线程内核对象上下文结构中的数据加载到CPU寄存器。
上下文切换还有一个操作是:CPU高速缓存的中的数据存到RAM中,新线程执行前从RAM中将数据存储到CPU高速缓存中。
线程可以提前终止时间片,什么也不做。如等待用户输入。只有用户输入的时候,CPU才会调用该线程。
垃圾回收的时候CLR会挂起所有线程。
结论:尽量少使用线程,线程上下文切换和其他的一些操作消耗了大量时间和内存。但有的时候又必须使用线程。
CPU发展趋势
可以查看windows的进程和线程情况:任务选项卡-性能;详细信息。
CPU的发展正在面临着:多个CPU,超线程芯片,多核芯片。
CLR线程和Windows线程
CLR线程就是映射的Windows线程的逻辑线程,完全等价。在以前Microsoft做过一些努力使得CLR线程做一些额外的操作,但是失败了。
使用专用线程执行异步的计算限制操作
必须要避免创建线程来执行异步的操作,相反需要使用线程池执行异步的操作。
有一些特殊情况需要创建线程:
- 线程需要以非普通优先级运行。线程池都以普通优先级运行。
- 线程需要表现为前台线程。
- 执行长时间的任务。
- 启动线程并可能调用Thread的Abort来终止它。
using System;
using System.Threading;
public static class ThreadBasics {
public static void Main() {
FirstThread.Go();
BackgroundDemo.Go(true);
BackgroundDemo.Go(false);
}
}
internal static class FirstThread {
public static void Go() {
Console.WriteLine("Main thread: starting a dedicated thread " +
"to do an asynchronous operation");
Thread dedicatedThread = new Thread(ComputeBoundOp);
dedicatedThread.Start(5);
Console.WriteLine("Main thread: Doing other work here...");
Thread.Sleep(10000); // Simulating other work (10 seconds)
dedicatedThread.Join(); // Wait for thread to terminate
Console.ReadLine();
}
// This method's signature must match the ParametizedThreadStart delegate
private static void ComputeBoundOp(Object state) {
// This method is executed by another thread
Console.WriteLine("In ComputeBoundOp: state={0}", state);
Thread.Sleep(1000); // Simulates other work (1 second)
// When this method returns, the dedicated thread dies
}
}
internal static class BackgroundDemo {
public static void Go(Boolean background) {
// Create a new thread (defaults to Foreground)
Thread t = new Thread(new ThreadStart(ThreadMethod));
// Make the thread a background thread if desired
if (background) t.IsBackground = true;
t.Start(); // Start the thread
return; // NOTE: the application won't actually die for about 10 seconds
}
private static void ThreadMethod() {
Thread.Sleep(10000); // Simulate 10 seconds of work
Console.WriteLine("ThreadMethod is exiting");
}
}
线程调度和优先级
可以使用Microsoft Spy++工具查看线程的调度情况。在vs开发人员命名提示里输入spyxx就可以启动
Windows系统又称为抢占式多线程操作系统(preemptive multithreaded)。同时Windows不是实时操作系统。
每个线程都分配了从0(最低)到31(最高)的优先级。Windows先以轮流(round-robin)方法调用所有高优先级线程,直到该优先级所有线程不需要运行,才会调度下一层优先级中的线程。如果在执行低优先级线程的时候,有高优先级的线程需要运行,系统会立刻挂起(暂停)低优先级然后调度高优先级。
系统有一个零页线程(zero page thread),在系统没有线程需要运行的时候,零页线程负责将系统的RAM所有空闲页清零。
为了更好的规划优先级,Microsoft将进程和线程都划分了优先级类:进程:Idle,Below Normal,Normal,Above Normal,High,Realtime;线程:Idle,Lowest,Below Normal,Normal,Above Normal,Highest,Time-Critical。
优先级类与优先级的对应关系:
CLR终结器以线程Time-Critical优先级运行。
设置Thread的Priority属性向其传递ThreadPriority枚举类型定义的5个值来控制线程优先级。
前台线程和后台线程
一个进程中所有的前台线程停止时,所有的后台线程会立刻被终止。
每个AppDomain都可以运行一个单独应用程序,该应用程序有自己前台线程。所有前台线程都停止的时候,进程才会退出销毁。
线程可以从前台线程编程后台线程或则反向。应用程序主线程以及通过构造一个Thread对象显式创建的任何线程都默认为前台线程。线程池的线程都默认为后台线程。进入托管环境的本机代码创建的线程都是后台线程。
计算限制的异步操作
CLR线程池基础
每个CLR拥有一个线程池,也就是一个线程池为该CLR控制的所有AppDomain共享。
CLR的工作模式:
- CLR初始化时,线程池没有线程
- 当有异步操作时,将一个记录项(entry)追加到线程池队列中。
- 线程池代码将获得记录项将其派发(dispatch)给一个线程。
- 如果没有线程就创建一个线程。
- 完成任务后,线程回到线程池,进入空闲状态(不进行销毁)。
- 如果线程一直空闲,一段时间后会醒来释放自己。
执行简单的计算限制操作
ThreadPool定义的异步方法和回调委托:
static Boolean QueueUserWorkItem(WaitCallback callBack);
static Boolean QueueUserWorkItem(WaitCallback callBack,Object state);
delegate void WaitCallback(Object state);
//执行
ExecutionContexts.Go();
internal static class ThreadPoolDemo {
public static void Go() {
Console.WriteLine("Main thread: queuing an asynchronous operation");
ThreadPool.QueueUserWorkItem(ComputeBoundOp, 5);
Console.WriteLine("Main thread: Doing other work here...");
Thread.Sleep(10000); // Simulating other work (10 seconds)
Console.ReadLine();
}
// This method's signature must match the WaitCallback delegate
private static void ComputeBoundOp(Object state) {
// This method is executed by a thread pool thread
Console.WriteLine("In ComputeBoundOp: state={0}", state);
Thread.Sleep(1000); // Simulates other work (1 second)
// When this method returns, the thread goes back
// to the pool and waits for another task
}
}
//结果
Main thread: queuing an asynchronous operation
Main thread: Doing other work here...
In ComputeBoundOp: state=5
执行上下文
每个线程都关联一个执行上下文(Execution context),执行上下文包括很多东西:安全设置,宿主设置,上下文数据。
每当初始线程使用辅助线程执行任务时,初始线程的执行上下文会复制到辅助线程,保证辅助线程使用相同的安全设置和宿主设置,但这一操作会影响性能。
System.Threading.ExecutionContext类可以对执行上下文的复制功能进行控制:
public sealed class ExecutionContext:IDisposable, ISerializabel
{
[SecurityCritical]
public static AsyncFlowControl SuppressFlow();
public static void RestoreFlow();
public static Boolean IsFlowSuppressed();
// 未列出不常用的方法
}
阻止执行上下文可以显著提升服务器应用程序,而客户端应用程序提升不明显。
//调用
ExecutionContexts.Go();
internal static class ExecutionContexts
{
public static void Go()
{
// Put some data into the Main thread’s logical call context
CallContext.LogicalSetData("Name", "Jeffrey");
// Initiate some work to be done by a thread pool thread
// The thread pool thread can access the logical call context data
ThreadPool.QueueUserWorkItem(
state => Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name")));
// Suppress the flowing of the Main thread’s execution context
ExecutionContext.SuppressFlow();
// Initiate some work to be done by a thread pool thread
// The thread pool thread can NOT access the logical call context data
ThreadPool.QueueUserWorkItem(
state => Console.WriteLine("Name={0}", CallContext.LogicalGetData("Name")));
// Restore the flowing of the Main thread’s execution context in case
// it employs more thread pool threads in the future
ExecutionContext.RestoreFlow();
SecurityExample();
}
private static void SecurityExample()
{
ProxyType highSecurityObject = new ProxyType();
highSecurityObject.AttemptAccess("High"); // Works OK
PermissionSet grantSet = new PermissionSet(PermissionState.None);
grantSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
AppDomain lowSecurityAppDomain = AppDomain.CreateDomain("LowSecurity", null, new AppDomainSetup() { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory }, grantSet, null);
ProxyType lowSecurityObject = (ProxyType)lowSecurityAppDomain.CreateInstanceAndUnwrap(typeof(ProxyType).Assembly.ToString(), typeof(ProxyType).FullName);
lowSecurityObject.DoSomething(highSecurityObject);
Console.ReadLine();
}
public sealed class ProxyType : MarshalByRefObject
{
// This method executes in the low-security AppDomain
public void DoSomething(ProxyType highSecurityObject)
{
AttemptAccess("High->Low"); // Throws
// Attempt access from the high-security AppDomain via the low-security AppDomain: Throws
highSecurityObject.AttemptAccess("High->Low->High");
// Have the high-security AppDomain via the low-security AppDomain queue a work item to
// the thread pool normally (without suppressing the execution context): Throws
highSecurityObject.AttemptAccessViaThreadPool(false, "TP (with EC)->High");
// Wait a bit for the work item to complete writing to the console before starting the next work item
Thread.Sleep(1000);
// Have the high-security AppDomain via the low-security AppDomain queue a work item to
// the thread pool suppressing the execution context: Works OK
highSecurityObject.AttemptAccessViaThreadPool(true, "TP (no EC)->High");
}
public void AttemptAccessViaThreadPool(Boolean suppressExecutionContext, String stack)
{
// Since the work item is queued from the high-security AppDomain, the thread pool
// thread will start in the High-security AppDomain with the low-security AppDomain's
// ExecutionContext (unless it is suppressed when queuing the work item)
using (suppressExecutionContext ? (IDisposable)ExecutionContext.SuppressFlow() : null) {
ThreadPool.QueueUserWorkItem(AttemptAccess, stack);
}
}
public void AttemptAccess(Object stack)
{
String domain = AppDomain.CurrentDomain.IsDefaultAppDomain() ? "HighSecurity" : "LowSecurity";
Console.Write("Stack={0}, AppDomain={1}, Username=", stack, domain);
try {
Console.WriteLine(Environment.GetEnvironmentVariable("USERNAME"));
}
catch (SecurityException) {
Console.WriteLine("(SecurityException)");
}
}
}
}
//结果
Name=Jeffrey
Name=
Stack=High, AppDomain=HighSecurity, Username=dujinfeng
Stack=High->Low, AppDomain=LowSecurity, Username=(SecurityException)
Stack=High->Low->High, AppDomain=HighSecurity, Username=(SecurityException)
Stack=TP (with EC)->High, AppDomain=HighSecurity, Username=(SecurityException)
Stack=TP (no EC)->High, AppDomain=HighSecurity, Username=dujinfeng
协作式取消和超时
协作式取消就是需要显式调用取消。
怎样显式调用取消:
- System.Threading.CancellationTokenSource包含了取消有关的所有状态,其为引用类型,可以利用它的Token属性获得CancellationToken值类型来进行取消操作。
public sealed class CancellationTokenSource:IDisposable //引用类型
{
public CancellationTokenSource();
public void Dispose();//释放资源比如WaitHandle
public Boolean IsCancellationRequested {get;}
public void Cancel();
public void Cancel(Boolean throwOnFirstException);
}
CancellationToken轻量级值类型,有一个字段包含对CancellationTokenSource对象的引用
public struct CancellationToken //一个值类型
{
public static CancellationToken None {get;} //很好用
public Boolean IsCancellationRequested {get;} //通过非Task调用的操作调用
public void ThrowIfCancellationRequested();//通过Task调用的操作调用
// CancellationTokenSource取消时,WaitHandIe会收到信号
public WaitHandle WaitHandle {get;}
//GetHashCode,Equals,operator==和operaor!=成员未列出
public Boolean CanBeCanceLed {get;}//很少使用
public CancellationTokenRegistration Register(Action<Object> callback, Object state, Boolean useSynchromzatronContext);//未列出更简单的重载版本
}
TaskDemo.Go();
internal static class CancellationDemo {
public static void Go() {
CancellingAWorkItem();
Register();
Linking();
}
private static void CancellingAWorkItem() {
CancellationTokenSource cts = new CancellationTokenSource();
// Pass the CancellationToken and the number-to-count-to into the operation
ThreadPool.QueueUserWorkItem(o => Count(cts.Token, 1000));
Console.WriteLine("Press <Enter> to cancel the operation.");
Console.ReadLine();
cts.Cancel(); // If Count returned already, Cancel has no effect on it
// Cancel returns immediately, and the method continues running here...
Console.ReadLine(); // For testing purposes
}
private static void Count(CancellationToken token, Int32 countTo) {
for (Int32 count = 0; count < countTo; count++) {
if (token.IsCancellationRequested) {
Console.WriteLine("Count is cancelled");
break; // Exit the loop to stop the operation
}
Console.WriteLine(count);
Thread.Sleep(200); // For demo, waste some time
}
Console.WriteLine("Count is done");
}
private static void Register() {
var cts = new CancellationTokenSource();
cts.Token.Register(() => Console.WriteLine("Canceled 1"));
cts.Token.Register(() => Console.WriteLine("Canceled 2"));
// To test, let's just cancel it now and have the 2 callbacks execute
cts.Cancel();
}
private static void Linking() {
// Create a CancellationTokenSource
var cts1 = new CancellationTokenSource();
cts1.Token.Register(() => Console.WriteLine("cts1 canceled"));
// Create another CancellationTokenSource
var cts2 = new CancellationTokenSource();
cts2.Token.Register(() => Console.WriteLine("cts2 canceled"));
// Create a new CancellationTokenSource that is canceled when cts1 or ct2 is canceled
/* Basically, Constructs a new CTS and registers callbacks with all he passed-in tokens. Each callback calls Cancel(false) on the new CTS */
var ctsLinked = CancellationTokenSource.CreateLinkedTokenSource(cts1.Token, cts2.Token);
ctsLinked.Token.Register(() => Console.WriteLine("linkedCts canceled"));
// Cancel one of the CancellationTokenSource objects (I chose cts2)
cts2.Cancel();
// Display which CancellationTokenSource objects are canceled
Console.WriteLine("cts1 canceled={0}, cts2 canceled={1}, ctsLinked canceled={2}",
cts1.IsCancellationRequested, cts2.IsCancellationRequested, ctsLinked.IsCancellationRequested);
}
}
//结果
不可取消操作可以使用CancellationToken的静态None属性。该属性返回一个特殊的CancellationToken对象,该对象的IsCancellationRequest总是返回false。
可调用CancellationTokenSource的Register方法注册一个在线程取消时调用的方法。向该方法传递一个Action<Object>委托和一个bool值(名为useSynchronizationContext),bool值用来控制是否使用调用线程(false:调用register的线程)的SynchronizationContext(回调方法会被send(同步调用)给它,而不是post(异步调用))来调用委托,使用为true,不使用为false,如果不使用回调方法会被顺序执行。
Rigister中注册多个回调方法发生异常,要看一下CancellationTokenSource的Cancel方法,如果向该方法传递true,那么异常会阻塞回调方法的调用,如果是false,回调方法不会被阻塞,所有异常会被添加到集合中。该集合在Cancel抛出异常AggregateException的实例InnerExceptions属性中
Register方法返回一个CancellationTokenRegistration对象。
public struct CancellationTokenRegistration:
{
IEquatable<CancellationTokenRegistration>, IDisposable
{
public void Dispose();
// GetHashCode, Equals, operator==和operator!=成员未列出
}
}
调用其Dispose可以取消回调函数调用。
可以使用CancellationTokenSource的CreateLinkedTokenSource方法连接一个CancellationTokenSource对象,返回一个CancellationTokenSource对象,任何一个对象被取消新的对象就会被取消。
CancellationDemo.Go();
internal static class CancellationDemo {
public static void Go() {
CancellingAWorkItem();
Register();
Linking();
}
private static void CancellingAWorkItem() {
CancellationTokenSource cts = new CancellationTokenSource();
// Pass the CancellationToken and the number-to-count-to into the operation
ThreadPool.QueueUserWorkItem(o => Count(cts.Token, 1000));
Console.WriteLine("Press <Enter> to cancel the operation.");
Console.ReadLine();
cts.Cancel(); // If Count returned already, Cancel has no effect on it
// Cancel returns immediately, and the method continues running here...
Console.ReadLine(); // For testing purposes
}
private static void Count(CancellationToken token, Int32 countTo) {
for (Int32 count = 0; count < countTo; count++) {
if (token.IsCancellationRequested) {
Console.WriteLine("Count is cancelled");
break; // Exit the loop to stop the operation
}
Console.WriteLine(count);
Thread.Sleep(200); // For demo, waste some time
}
Console.WriteLine("Count is done");
}
private static void Register() {
var cts = new CancellationTokenSource();
cts.Token.Register(() => Console.WriteLine("Canceled 1"));
cts.Token.Register(() => Console.WriteLine("Canceled 2"));
// To test, let's just cancel it now and have the 2 callbacks execute
cts.Cancel();
}
private static void Linking() {
// Create a CancellationTokenSource
var cts1 = new CancellationTokenSource();
cts1.Token.Register(() => Console.WriteLine("cts1 canceled"));
// Create another CancellationTokenSource
var cts2 = new CancellationTokenSource();
cts2.Token.Register(() => Console.WriteLine("cts2 canceled"));
// Create a new CancellationTokenSource that is canceled when cts1 or ct2 is canceled
/* Basically, Constructs a new CTS and registers callbacks with all he passed-in tokens. Each callback calls Cancel(false) on the new CTS */
var ctsLinked = CancellationTokenSource.CreateLinkedTokenSource(cts1.Token, cts2.Token);
ctsLinked.Token.Register(() => Console.WriteLine("linkedCts canceled"));
// Cancel one of the CancellationTokenSource objects (I chose cts2)
cts2.Cancel();
// Display which CancellationTokenSource objects are canceled
Console.WriteLine("cts1 canceled={0}, cts2 canceled={1}, ctsLinked canceled={2}",
cts1.IsCancellationRequested, cts2.IsCancellationRequested, ctsLinked.IsCancellationRequested);
}
}
//结果
Press <Enter> to cancel the operation.
0
1
2
3
Count is cancelled
Count is done
Canceled 2
Canceled 1
linkedCts canceled
cts2 canceled
cts1 canceled=False, cts2 canceled=True, ctsLinked canceled=True
请按任意键继续. . .
CancellationTokenSource提供了指定时间后自动取消的对象方法CancelAfter:
public sealed class CancellationTokenSource:IDisposab1e{//一个引用类型
public CancellationTokenSource(Int32 millisecondsDeiay):
public CancellationTokenSource (TimeSpandelay);
public void CancelAfter (Int32 millisecondsDeiay);
public Void CancelAfter (TimeSpandelay);
}
任务
ThreadPool的QueueUserWorkItem方法的弊端
- 不知道线程什么时候完成
- 不能获得线程返回值
System.Threading.Tasks可以解决这些问题。
private static void UsingTaskInsteadOfQueueUserWorkItem() {
ThreadPool.QueueUserWorkItem(ComputeBoundOp, 5);
new Task(ComputeBoundOp, 5).Start();
Task.Run(() => ComputeBoundOp(5));
}
Task构造函数接收一个Action或Action<Object>委托,静态方法Run需要传递一个Action或Func<TResult>委托。
还可以使用TaskCreationOptions标志来控制Task的执行。
等待任务完成并获取结果
private static void WaitForResult() {
// Create and start a Task
Task<Int32> t = new Task<Int32>(n => Sum((Int32)n), 10000);
// You can start the task sometime later
t.Start();
// Optionally, you can explicitly wait for the task to complete
t.Wait(); // FYI: Overloads exist accepting a timeout/CancellationToken
// Get the result (the Result property internally calls Wait)
Console.WriteLine("The sum is: " + t.Result); // An Int32 value
}
Task<TResult>对象可以获得Task返回的结果。
Wait会使调用Wait的线程阻塞,等待Task结束,如果Task没有开始就用调用Wait线程执行Task。
如果Task任务抛出异常,不会被阻塞,直接存储到异常集合中,在t.Wait或t.Result会抛出System.AggregateException异常。该异常的InnerExceptions(返回ReadOnlyCollection<Exception>)和InnerException(从Exception集成)
System.AggregateException的一些功能:
- GetBaseException方法,返回最内层AggregateException
- Flatten属性,新建一个AggregateException,其InnerExceptions属性包含一个异常列表
- Handle方法,使AggregateException中每个异常都调用一个回调方法
如果不调用Wait或Result方法或不查询task的Exception属性,就不会注意到异常,可以向TaskSchedule的静态UnobservedTaskException事件登记一个回调方法,如果在task被垃圾回收时发现有没有被注意的异常,会触发这个事件,并传递一个UnobservedTaskException对象,其包含一个AggregateException对象。
private static void UnobservedException() {
TaskScheduler.UnobservedTaskException += (sender, e) => {
//e.SetObserved();
Console.WriteLine("Unobserved exception {0}", e.Exception, e.Observed);
};
Task parent = Task.Factory.StartNew(() => {
Task child = Task.Factory.StartNew(() => { throw new InvalidOperationException(); }, TaskCreationOptions.AttachedToParent);
// Child’s exception is observed, but not from its parent
child.ContinueWith((task) => { var _error = task.Exception; }, TaskContinuationOptions.OnlyOnFaulted);
});
// If we do not Wait, the finalizer thread will throw an unhandled exception terminating the process
//parent.Wait(); // throws AggregateException(AggregateException(InvalidOperationException))
parent = null;
Console.ReadLine(); // Wait for the tasks to finish running
GC.Collect();
Console.ReadLine();
}
//结果
/*
Unobserved exception System.AggregateException: 未通过等待任务或访问任务的 Exception 属性观察到任务的异常。因此,终结器 线程重新引发了未观察到的异常。 ---> System.AggregateException: 发生一个或多个错误。 ---> System.InvalidOperationException: 对象的当前状态使该操作无效。
在 TaskDemo.<>c.<UnobservedException>b__8_2() 位置 C:\Users\dujinfeng\Desktop\NetCLRVia\CLR-via-C-4th-Edition-Code\Ch27-1-ComputeOps.cs:行号 355
在 System.Threading.Tasks.Task.InnerInvoke()
在 System.Threading.Tasks.Task.Execute()
--- 内部异常堆栈跟踪的结尾 ---
--- 内部异常堆栈跟踪的结尾 ---
---> (内部异常 #0) System.AggregateException: 发生一个或多个错误。 ---> System.InvalidOperationException: 对象的当前状态使该操作无效。
在 TaskDemo.<>c.<UnobservedException>b__8_2() 位置 C:\Users\dujinfeng\Desktop\NetCLRVia\CLR-via-C-4th-Edition-Code\Ch27-1-ComputeOps.cs:行号 355
在 System.Threading.Tasks.Task.InnerInvoke()
在 System.Threading.Tasks.Task.Execute()
--- 内部异常堆栈跟踪的结尾 ---
---> (内部异常 #0) System.InvalidOperationException: 对象的当前状态使该操作无效。
在 TaskDemo.<>c.<UnobservedException>b__8_2() 位置 C:\Users\dujinfeng\Desktop\NetCLRVia\CLR-via-C-4th-Edition-Code\Ch27-1-ComputeOps.cs:行号 355
在 System.Threading.Tasks.Task.InnerInvoke()
在 System.Threading.Tasks.Task.Execute()<---
<---
*/
请按任意键继续. . .
Task还提供了两个静态方法,允许等待一个Task对象数组
- WaitAny,阻塞调用线程,等待任何一个Task完成,返回一个Int32的task数组索引,超时返回-1,通过CancellationToken取消会抛出Operation'Cancel'Exception异常。
- WaitAll,阻塞调用线程,等待所有Task完成。其他和WaitAny一样。
取消任务
private static void Cancel() {
CancellationTokenSource cts = new CancellationTokenSource();
Task<Int32> t = Task.Run(() => Sum(cts.Token, 10000), cts.Token);
// Sometime later, cancel the CancellationTokenSource to cancel the Task
cts.Cancel();//这是一个异步请求
try {
// If the task got canceled, Result will throw an AggregateException
Console.WriteLine("The sum is: " + t.Result); // An Int32 value
}
catch (AggregateException ae) {
// Consider any OperationCanceledException objects as handled.
// Any other exceptions cause a new AggregateException containing
// only the unhandled exceptions to be thrown
ae.Handle(e => e is OperationCanceledException);
// If all the exceptions were handled, the following executes
Console.WriteLine("Sum was canceled");
}
}
private static Int32 Sum(CancellationToken ct, Int32 n) {
Int32 sum = 0;
for (; n > 0; n--) {
// The following line throws OperationCanceledException when Cancel
// is called on the CancellationTokenSource referred to by the token
ct.ThrowIfCancellationRequested();
//Thread.Sleep(0); // Simulate taking a long time
checked { sum += n; }
}
return sum;
}
任务完成启动新任务
wait和result都可能会阻塞调用线程,可以使用ContinueWith来使得任务完成启动另一个Task,做Task完成做的事情。
private static void ContinueWith() {
// Create and start a Task, continue with another task
Task<Int32> t = Task.Run(() => Sum(10000));
// ContinueWith returns a Task but you usually don't care
Task cwt = t.ContinueWith(task => Console.WriteLine("The sum is: " + task.Result));
cwt.Wait(); // For the testing only
}
private static Int32 Sum(Int32 n) {
Int32 sum = 0;
for (; n > 0; n--) checked { sum += n; }
return sum;
}
如果在调用ContinueWith之前Task已经完成,直接显示结果。
Task对象内部包含ContinueWith任务的集合,Task可以多次调用ContinueWith方法,在调用ContunueWith时可以传递TaskContinuationOptions枚举来控制Task任务。
[Flags,Serializab1e]
public enum TaskContinuationOptions{
None = 0x0000,//默认
//提议TaskSchedu1er你希望该任务尽快执行,
PreferFairness = 0x0001,
//提议TaskSchedu1er应尽可能地创建线程池线程
LongRunning = 0x0002,
//该提议总是被采纳:将一个Task和它的父Task关联(稍后讨论)
AttachedToParent =0x0004,
//任务试图和这个父任务连接将抛出一个invalidOperationException
DenyChi1dAttach = 0x0008,
//强迫了任务使用默认调度器而不是父仃务的调度器
HideScheduler = 0x0010,
//除非前置任务(antecedent task)完成,否则禁正延续任务完成(取消)
LazyCance11ation = 0x0020,
//这个标志指出你希望由执行第一个任务的线程执行
//ContinueWith任务。第一个任务完成后,调用
//continuewith的线程接着执行ContinueWith任务
ExecuteSynchronously = 0x80000,
//这些标志指出在什么情况下运行ContinueWith任务
NotOnRanToComp1etion = 0x10000,
NotOnFaulted = 0x20000,
NotOnCance1ed = 0x4000,
//这些标志是以上三个标志的便利组合
OnlyOnCance1ed = NotOnRanToCompletion|NotOnFaulted,
OnlyOnFau1ted = NotOnRanToCompletion|NotOnCance1ed,
OnlyOnRanToComp1etion = NotOnFaulted|NotOnCanceled,
}
private static void MultipleContinueWith() {
// Create and start a Task, continue with multiple other tasks
Task<Int32> t = Task.Run(() => Sum(10000));
// Each ContinueWith returns a Task but you usually don't care
t.ContinueWith(task => Console.WriteLine("The sum is: " + task.Result),
TaskContinuationOptions.OnlyOnRanToCompletion);
t.ContinueWith(task => Console.WriteLine("Sum threw: " + task.Exception),
TaskContinuationOptions.OnlyOnFaulted);
t.ContinueWith(task => Console.WriteLine("Sum was canceled"),
TaskContinuationOptions.OnlyOnCanceled);
try {
t.Wait(); // For the testing only
}
catch (AggregateException) {
}
}
任务可以启动子任务
private static void ParentChild() {
Task<Int32[]> parent = new Task<Int32[]>(() => {
var results = new Int32[3]; // Create an array for the results
// This tasks creates and starts 3 child tasks
new Task(() => results[0] = Sum(10000), TaskCreationOptions.AttachedToParent).Start();
new Task(() => results[1] = Sum(20000), TaskCreationOptions.AttachedToParent).Start();
new Task(() => results[2] = Sum(30000), TaskCreationOptions.AttachedToParent).Start();
// Returns a reference to the array (even though the elements may not be initialized yet)
return results;
});
// When the parent and its children have run to completion, display the results
var cwt = parent.ContinueWith(parentTask => Array.ForEach(parentTask.Result, Console.WriteLine));
// Start the parent Task so it can start its children
parent.Start();
cwt.Wait(); // For testing purposes
}
private static Int32 Sum(Int32 n) {
Int32 sum = 0;
for (; n > 0; n--) checked { sum += n; }
return sum;
}
Task内部揭秘
Task对象是很消耗资源,如果不需要一些额外的功能ThreadPool.QueueUserWorkItem的利用率更高。
Task的组成:
- Int32 ID:只读唯一Id属性,创建时初始化为0,首次查询时赋值,该值从1开始递增,VS调试器可以查看该值,Task.CurrentId可在即时窗口调用,并在并行任务查找该值找到自己的任务。
- Int32 执行状态,status属性,返回TaskStatus枚举。首次构造Task状态是Created,Task启动状态WaitingToRun,Task在一个线程运行状态Running,还有几个Task属性可以提供状态的查询。
public enum TaskStatus
{
//这些标志指出一个Task在其生命期内的状态
Created,//任务己显式创建:可以手动start()这个任务
WaitingForActivation,//任务已隐式创建;会自动开始
WaitingToRun,//任务己调度,但尚未运行
Running,//任务正在运行
WaitingForChildrenToComplete,//任务正在等待它的子任务完成,子任务完成后它才完成
//任务的最终状态是以下三个之一:
RanToCompletion,
Canceled,
Faulted
}
- 对父任务的引用
- 创建时指定的TaskScheduler引用
- 回调方法的引用
- 传给回调方法对象的引用(通过AsyncState属性查询)
- ExecutionContext的引用
- ManualResetEventSlim的引用
- 补充状态的引用,补充状态包括:CancellationToken、ContinueWithTask对象集合,为异常准备的Task集合
Task和Task<TResult>实现了IDisposable接口,Dispose主要内容是关闭ManualResetEventSlim,建以不要显示调用。
任务工厂
Task工厂主要是启动一组相同配置和相同参数的Tasks设计的。TaskFactory<Int32>,创建Task<Int32>的工厂,共同享有CancellationTokenSource标记,创建的所有延续Task都以同步方式进行,所有Task对象都使用默认TaskScheduler。
private static void TaskFactory() {
Task parent = new Task(() => {
var cts = new CancellationTokenSource();
var tf = new TaskFactory<Int32>(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
// 启动taskfactory创建3个子任务
var childTasks = new[] {
tf.StartNew(() => Sum(cts.Token, 10000)),
tf.StartNew(() => Sum(cts.Token, 20000)),
tf.StartNew(() => Sum(cts.Token, Int32.MaxValue)) // Too big, throws OverflowException
};
// 任何子任务抛出异常,就取消其余子任务
for (Int32 task = 0; task < childTasks.Length; task++)
childTasks[task].ContinueWith(t => cts.Cancel(), TaskContinuationOptions.OnlyOnFaulted);
// 所有子任务完成后,从未出错/未取消的任务获取返回的最大值
// 然后将最大值传给另一个task来显示最大结果
tf.ContinueWhenAll(
childTasks,
completedTasks => completedTasks.Where(t => t.Status == TaskStatus.RanToCompletion).Max(t => t.Result),
CancellationToken.None)
.ContinueWith(t => Console.WriteLine("The maximum is: " + t.Result),
TaskContinuationOptions.ExecuteSynchronously).Wait(); // 等待测试
});
// 子任务完成后,也显示任何未处理的异常
parent.ContinueWith(p => {
// 所有文本放到一个StringBuilder中,并只调用Console.WriteLine一次
// 因为这个任务可能和上面的任务并行执行
StringBuilder sb = new StringBuilder("The following exception(s) occurred:" + Environment.NewLine);
foreach (var e in p.Exception.Flatten().InnerExceptions)
sb.AppendLine(" " + e.GetType().ToString());
Console.WriteLine(sb.ToString());
}, TaskContinuationOptions.OnlyOnFaulted);
// 启动父任务,使它能启动子任务
parent.Start();
try {
parent.Wait(); // For testing purposes
}
catch (AggregateException) {
}
}
private static Int32 Sum(CancellationToken ct, Int32 n) {
Int32 sum = 0;
for (; n > 0; n--) {
// The following line throws OperationCanceledException when Cancel
// is called on the CancellationTokenSource referred to by the token
ct.ThrowIfCancellationRequested();
//Thread.Sleep(0); // Simulate taking a long time
checked { sum += n; }
}
return sum;
}
任务调度器
FCL提供了两个从TaskScheduler类型派生的调度器:线程调度器(thread pool task scheduler)和同步上下文调度器(synchronization context task scheduler)。默认使用线程调度器。
同步上下文调度器更适合GUI程序。该调度器不适用线程池,通过TaskScheduler.FormCurretSynchronizationContext方法获得该调度器。
private static void SynchronizationContextTaskScheduler() {
var f = new MyForm();
System.Windows.Forms.Application.Run();
}
private sealed class MyForm : System.Windows.Forms.Form {
private readonly TaskScheduler m_syncContextTaskScheduler;
public MyForm() {
// Get a reference to a synchronization context task scheduler
m_syncContextTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
Text = "Synchronization Context Task Scheduler Demo";
Visible = true; Width = 400; Height = 100;
}
private CancellationTokenSource m_cts;
protected override void OnMouseClick(System.Windows.Forms.MouseEventArgs e) {
if (m_cts != null) { // An operation is in flight, cancel it
m_cts.Cancel();
m_cts = null;
} else { // An operation is not in flight, start it
Text = "Operation running";
m_cts = new CancellationTokenSource();
// This task uses the default task scheduler and executes on a thread pool thread
Task<Int32> t = Task.Run(() => Sum(m_cts.Token, 20000), m_cts.Token);
// These tasks use the synchronization context task scheduler and execute on the GUI thread
t.ContinueWith(task => Text = "Result: " + task.Result,
CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion,
m_syncContextTaskScheduler);
t.ContinueWith(task => Text = "Operation canceled",
CancellationToken.None, TaskContinuationOptions.OnlyOnCanceled,
m_syncContextTaskScheduler);
t.ContinueWith(task => Text = "Operation faulted",
CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted,
m_syncContextTaskScheduler);
}
base.OnMouseClick(e);
}
}
private static Int32 Sum(CancellationToken ct, Int32 n) {
Int32 sum = 0;
for (; n > 0; n--) {
// The following line throws OperationCanceledException when Cancel
// is called on the CancellationTokenSource referred to by the token
ct.ThrowIfCancellationRequested();
//Thread.Sleep(0); // Simulate taking a long time
checked { sum += n; }
}
return sum;
}
Parallel Extensions Extras 提供了额外的调度器
Parallel的静态For,ForEach,和Invoke方法
多个方法并行或顺序执行,使用线程池,内部使用Task。同时调用线程会将自己挂起,直到所有工作完成。任何一个Task出现异常,都会抛出AggregateException异常。多个线程需要添加线程同步锁保护共享数据。
private static void SimpleUsage() {
// One thread performs all this work sequentially
for (Int32 i = 0; i < 1000; i++) DoWork(i);
// The thread pool’s threads process the work in parallel
Parallel.For(0, 1000, i => DoWork(i));
var collection = new Int32[0];
// One thread performs all this work sequentially
foreach (var item in collection) DoWork(item);
// The thread pool’s threads process the work in parallel
Parallel.ForEach(collection, item => DoWork(item));
// One thread executes all the methods sequentially
Method1();
Method2();
Method3();
// The thread pool’s threads execute the methods in parallel
Parallel.Invoke(
() => Method1(),
() => Method2(),
() => Method3());
}
private static void DoWork(Int32 i) { }
private static void Method1() { }
private static void Method2() { }
private static void Method3() { }
ParallelOptions对象用于控制Parallel
public class ParallelOptions
{
public ParallelOptions();
//允许取消操作
public CancellationToken CancellationToken{get;set;}//默认为CancellationToken.None
//允许指定可以并发操作的最大工作项数目
public Int32MaxDegreeOfParallelism {get;set;}//默认为-1(可用CPU数)
//允许指定要使用哪个TaskScheduler
public TaskSchedulerTaskScheduler {get;set;}//默认为TaskScheduler.Default
}
有一些For和Foreach的重载版本允许3个委托
- Task初始化委托(localInit):每个任务被处理前调用
- Task主体委托(body):每个任务处理时调用
- Task总结委托(localFinally):每个任务结束的时候调用
计算一个目录中所有文件字节的长度.
String path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
Console.WriteLine("The total bytes of all files in {0} is {1:N0}.",
path, DirectoryBytes(@path, "*.*", SearchOption.TopDirectoryOnly));
private static Int64 DirectoryBytes(String path, String searchPattern, SearchOption searchOption) {
var files = Directory.EnumerateFiles(path, searchPattern, searchOption);
Int64 masterTotal = 0;
ParallelLoopResult result = Parallel.ForEach<String, Int64>(files,
() => { // localInit: 每个任务开始之前调用一次
// 每个任务开始之前,总计值都初始化为0
return 0; // 将taskLocalTotal初始值为 0
},
(file, parallelLoopState, index, taskLocalTotal) => { // body: 每个工作项调用一次
// 获得这个文件的大小,把它添加到这个任务的累加值上
Int64 fileLength = 0;
FileStream fs = null;
try {
fs = File.OpenRead(file);
fileLength = fs.Length;
}
catch (IOException) { /* Ignore any files we can't access */ }
finally { if (fs != null) fs.Dispose(); }
return taskLocalTotal + fileLength;
},
taskLocalTotal => { // 每个任务完成时调用
//将这个任务的总计值taskLocalTotal添加到总的总计值mastertotal上
Interlocked.Add(ref masterTotal, taskLocalTotal);
});
return masterTotal;
}
//结果
The total bytes of all files in C:\Users\dujinfeng\Documents is 2,698.
请按任意键继续. . .
委托主体传递了一个ParallelLoopState对象,可以通过该对象与参与工作的其他任务进行交互,Stop方法使得循环停止,Break方法使得循环不再处理当前项之后的项.LoweatBreakIteration属性返回处理过程中调用过Break方法的最低项,如果没有break过,就返回null.
public calss ParallelLoopState
{
public void Stop();
public Boolean IsStopped{ get; }
public void Break();
public Int64? LowestBreakIteration{ get; }
public Boolean IsExceptional{ get; }
public Boolean ShouldExitCurrentIteration{ get; }
}
在处理任何一项任务造成了异常,IsException属性会返回true,如果调用过Stop,Break,CancellationTokenSource,查询ShouldExitCurrentIteration就会返回true。
For和ForEach会返回ParalleLoopResult实例,
public struct ParallelLoopResult
{
//如果操作提提前终止,以下方法返回false
public Boolean IsCompleted{get;}
public INt64? LowestBreakIteration{get;}
}
如果正常运行完IsCompleted返回true。
并行语言集成查询
顺序查询和并行查询(Parallel LINQ),System.Linq.ParallelEnumerable类实现了PLINQ的所有功能。PatallelEnumerable的AsParallel扩展方法可以将顺序查询(基于IEnumerable或者IEnumerable<T>)转换成并行查询(基于ParallelQuery或ParallelQuery<T>)
public static ParallelQuery<TSource> AsParallel<TSource>(this IEnumerable<TSource> source);
public static ParallelQuery AsParallel(this IEnumerable source);
例子返回一个程序集所有过时(obsolete)方法
//调用
ObsoleteMethods(typeof(Object).Assembly);
private static void ObsoleteMethods(Assembly assembly) {
var query =
from type in assembly.GetExportedTypes().AsParallel()
from method in type.GetMethods(BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static)
let obsoleteAttrType = typeof(ObsoleteAttribute)
where Attribute.IsDefined(method, obsoleteAttrType)
orderby type.FullName
let obsoleteAttrObj = (ObsoleteAttribute)
Attribute.GetCustomAttribute(method, obsoleteAttrType)
select String.Format("Type={0}\nMethod={1}\nMessage={2}\n",
type.FullName, method.ToString(), obsoleteAttrObj.Message);
// Display the results
foreach (var result in query) Console.WriteLine(result);
// Alternate (not as fast): query.ForAll(Console.WriteLine);
}
//结果
Type=Microsoft.Win32.RegistryHive
Method=System.String ToString(System.IFormatProvider)
Message=The provider argument is not used. Please use ToString().
Type=Microsoft.Win32.RegistryHive
Method=System.String ToString(System.String, System.IFormatProvider)
Message=The provider argument is not used. Please use ToString(String).
Type=Microsoft.Win32.RegistryKeyPermissionCheck
Method=System.String ToString(System.String, System.IFormatProvider)
Message=The provider argument is not used. Please use ToString(String).
Type=Microsoft.Win32.RegistryKeyPermissionCheck
Method=System.String ToString(System.IFormatProvider)
Message=The provider argument is not used. Please use ToString().
Type=Microsoft.Win32.RegistryOptions
Method=System.String ToString(System.IFormatProvider)
Message=The provider argument is not used. Please use ToString().
ParallelEnumerable的AsSequential方法可以将并行查询转换成顺序查询。
public static IEnumerable<TSource> AsSequential<TSource> (this ParallelQuery<TSource> source)
顺序查询中处理结果方法foreach在并行中可以用ParallelEnumerable的ForAll方法处理查询:
static void ForAll<TSource> (this ParallelQuery<TSource> source,Action<TSource> action);
//上面例子的最后foreach可以被替换为:
query.ForAll(Console.WriteLine);
但调用Console.WriteLine并行执行没有意义,其内部让线程同步,同时只有一个线程能访问控制台。
如果需要并行执行并保持顺序可以使用ParallelEnumerable的AsOrdered方法,排序方法Orderby,OrderbyDescending,ThenBy,ThenByDescending。不排序的方法Distinct,Except,Intersect,Union,Join,GroupBy,GroupJoin,ToLookup。
并行用来控制查询的方法WithCancellation<TSource>,WithDegreeOfParallelism<TSource>,WithExecutionMode<TSource>,WithMergeOptions<TSource>方法。
调用Concat,ElementAt,FIrst,Last,Skip,Take,Zip,Select等可以调用WithExecutionMode,向其传递ParallelExecutionMode标志,强迫以并行执行。
public enum ParallelExceptionMode
{
Default=0;//让并行Linq决定处理查询的最佳方式
ForceParallelism=1//强迫查询以其并行方式处理
}
并行处理,结果必须合并,可调用WithMergeOptions,向其传递ParallelMergeOptions标志,从而控制缓冲与合并方式
public enum ParallelMergeOptions
{
Default=0,//目前和AutoBuffered一样
NotBuffered=1,//结果一旦就绪就开始处理,最省内存,速度比较慢
AutoBuffered=2,//每个线程在处理前缓冲一些结果,介于之间
FullyBuffered=3//每个线程在处理前缓冲所有结果,运行速度最快,内存使用多
}
执行定时的计算限制操作
System.Threading.Timer定时器构造函数
puniic sealed class Timer:MarshalByRefObject,IDisposable{
public Timer(TimerCa11back callback,0bject stater,Int32 dueTime,Int32 period);
public Timer(TimerCallback callback,0bject state,UInt32 dueTime,UInt32 period);
public Timer(TimerCallback callback,Object state,Int64 dueTime,Int64 period);
public Timer(TimerCa1lback callback,0bject state,Timespan dueTime,TimeSpan Period);
}
//System.Threading.TimerCallback
delegate void TimerCallback(Object state);
在内部:所有Timer对象只使用一个线程,该线程知道Timer对象下一次什么时候到期,如果到期就会唤醒,调用ThreadPool的QueueUserWorkItem,
如果回调函数执行时间长,定时器有可能再次触发,造成多线程执行回调方法,针对这个问题,建以在构造Timer时,将period指定为Timeout.Infinite,这样只执行一次回调,在回调中使用Change指定新的dueTimer,并再次将Period执行Timeout.Infinite。
public sealed class Timer:MarshalByRefObject,IDisposabie
{
public Boolean Change(Int32 dueTime,Int32 period);
public Boolean Change(UInt32 dueTime,UInt32 period);
public Boo1eam Change(Int64 dueTime,Int64 period);
public Boolean Change(TimeSpan dueTime,Timespan period);
}
Timer类的Dispose方法完全取消计时器,在完成回调之后,向notifyObject参数标识的内核对象发出信号,
internal static class TimerDemo {
private static Timer s_timer;
public static void Go() {
Console.WriteLine("Checking status every 2 seconds");
// Create the Timer ensuring that it never fires. This ensures that
// s_timer refers to it BEFORE Status is invoked by a thread pool thread
s_timer = new Timer(Status, null, Timeout.Infinite, Timeout.Infinite);
// Now that s_timer is assigned to, we can let the timer fire knowing
// that calling Change in Status will not throw a NullReferenceException
s_timer.Change(0, Timeout.Infinite);
Console.ReadLine(); // Prevent the process from terminating
}
// This method's signature must match the TimerCallback delegate
private static void Status(Object state) {
// This method is executed by a thread pool thread
Console.WriteLine("In Status at {0}", DateTime.Now);
Thread.Sleep(1000); // Simulates other work (1 second)
// Just before returning, have the Timer fire again in 2 seconds
s_timer.Change(2000, Timeout.Infinite);
// When this method returns, the thread goes back
// to the pool and waits for another work item
}
}
//结果
Checking status every 2 seconds
In Status at 2020-02-22 06:57:32
In Status at 2020-02-22 06:57:35
In Status at 2020-02-22 06:57:38
In Status at 2020-02-22 06:57:41
In Status at 2020-02-22 06:57:44
还可以使用Task的Delay和async和await关键字来编码
internal static class DelayDemo {
public static void Go() {
Console.WriteLine("Checking status every 2 seconds");
Status();
Console.ReadLine(); // Prevent the process from terminating
}
// This method can take whatever parameters you desire
private static async void Status() {
while (true) {
Console.WriteLine("Checking status at {0}", DateTime.Now);
// Put code to check status here...
// At end of loop, delay 2 seconds without blocking a thread
await Task.Delay(2000); // await allows thread to return
// After 2 seconds, some thread will continue after await to loop around
}
}
}
定时器类别
- System.Threading.Timer类:最好的计时器,线程池上执行定时后台任务
- System.Windows.Forms.Timer类:将计时器与调用线程关联,这个计时器触发,Windows将一条计时器消息(WM_TIMER)注入线程消息队列,线程执行消息泵提取消息进行回调函数,所有这些工作都是一个线程完成,不会并发执行
- System.Windows.Threading.DispatcherTimer类:是Form.Timer类在Silverlight和WPF上的等价物
- Windows.UI.Xaml.DispatcherTimer类,Form.Timer在WindowsStore应用中的等价物
- SYstem.Timers.Timer类,本质上是Threading.Timer的包装类,是VS工具箱中的定时器允许放在设计器上,强烈建以不需要这个类,而改用System.Threading.Timer
线程池如何管理线程
微软的线程池技术相当的好,工作情况非常理想,很难搞出一个比CLR更好的线程池。
设置线程池限制
设置最大线程数,最好不要设置上限,如果发生饥饿或死锁,那么这些线程都会被阻塞,如果设置上限,就会导致没有新的空闲线程执行任务。
System.Threading.ThreadPool类提供了一些静态方法:GetMaxThreads,SetMaxThreads,GetMinThreads,SetMinThreads和GetAvailableThreads方法,可以设置和查询线程数,强烈建以不要使用上诉的任何方法。
管理工作者线程
线程池的线程都是工作者线程,主要讲解一下ThreadPool.QueueUserWorkItem,Timer类和Task异步执行时线程池操作的异同点:
- ThreadPool.QueueUserWorkItem,Timer类执行异步时,所有的工作项(回调函数)都被放到全局队列中,工作者线程采用先入先出(first in first out)算法将工作项从全局队列中取出,这使得所有工作者线程竞争一个线程同步锁,在某些应用程序中成为瓶颈。
- 使用TaskScheduler调度的Task对象。非工作者线程调度Task时,该Task被添加到全局队列。工作者线程调度一个Task时,该Task被添加到调用线程的本地队列(每个工作者线程都有自己的本地队列)。
- 工作者线程准备吹工作项,先检查本地队列,如果存在Task,就取出Task采用后入先出(LIFO)算法取出Task,注意的是工作者线程是唯一允许访问它自己本地队列头的线程,所以无需同步锁。
- 如果工作者线程本地队列为空,会尝试从另一个工作者队列的本地队列尾取一个Task,并要求获取同步锁。如果所有工作队列都空了,工作线程会使用FIFO算法从全局队列中提取工作项。如果全局队列也空了,工作者线程进入睡眠状态,如果睡眠时间太长,会自己醒来,销毁自身,并允许系统回收资源。
线程池默认创建CPU数量的工作线程,如果设置ThreadPool.SetMinThreads,则会创建设置值。
高速缓存区
cpu 一般拥有多个核心和一个cpu内的缓存(一般是L2),缓存一般位于cpu芯片内, 他的速度远远高于主板上的内存,一般来说cpu会把数据从内存加载到缓存中 ,这样可以获得更好的性能(特别是频繁使用的数据),高速缓存默认划分64 Byte为一个区域(这个数字可能在不同的平台上不一样, 可以通过 win32 api 函数 GetProcessorInformation 修改),一个区域在一个时间点只允许一个核心操作,那么完全可能一个线程在操作field1 的时候 , 运行于另外一个cpu上的另外一个线程想操作field2,就必须等待线程1完成以后才能获取这个缓存区域的访问.
例子:显式布局,性能提高了80%
internal static class FalseSharing {
#if true
private class Data {
// These two fields are right next to each other in
// memory; most-likely in the same cache line
public Int32 field1;
public Int32 field2;
}
#else
[StructLayout(LayoutKind.Explicit)]
private class Data {
// These two fields are right next to each other in
// memory; most-likely in the same cache line
[FieldOffset(0)]
public Int32 field1;
[FieldOffset(64)]
public Int32 field2;
}
#endif
private const Int32 iterations = 100000000;
private static Int32 s_operations = 2;
private static Stopwatch s_stopwatch;
public static void Go() {
Data data = new Data();
s_stopwatch = Stopwatch.StartNew();
ThreadPool.QueueUserWorkItem(o => AccessData(data, 0));
ThreadPool.QueueUserWorkItem(o => AccessData(data, 1));
Console.ReadLine();
}
private static void AccessData(Data data, Int32 field) {
for (Int32 x = 0; x < iterations; x++)
if (field == 0) data.field1++; else data.field2++;
if (Interlocked.Decrement(ref s_operations) == 0)
Console.WriteLine("Access time: {0}", s_stopwatch.Elapsed);
}
}
//结果,可能共享缓存
Access time: 00:00:01.0554650
//显式指定内存布局
Access time: 00:00:00.2595376
![](https://img2018.cnblogs.com/blog/1078802/201911/1078802-20191113193140309-238874463.png)
您的资助是我最大的动力!
金额随意,欢迎来赏!
出处:https://www.cnblogs.com/lovexinyi/
版权:本文版权归作者和博客园共有
转载:欢迎转载,但未经作者同意,必须保留此段声明;必须在文章中给出原文链接;否则必究法律责任