当前位置：首页 > news >正文

【C#】异步和多线程

news 2025/6/6 6:39:50

概念

1 进程-线程-多线程，同步和异步
2 委托启动异步调用
3 多线程特点：不卡主线程、速度快、无序性
4 异步的回调和状态参数
5 异步等待三种方式
6 异步返回值

多线程是.net开发非常重要的一块儿，
但是很多开发者工作多年，对多线程几乎不用/很畏惧/不明所以，写代码的时候没有考虑多线程的场景

进程：计算机概念，程序在服务器运行时占据全部计算资源综总和
虚拟的，
线程：计算机概念，进程在响应操作时最小单位，也包含cpu 内存网络硬盘io
虚拟的概念，更加看不见摸不着
一个进程会包含多个线程；线程隶属于某个进程，进程销毁线程也就没了
句柄：其实是个long数字，是操作系统标识应用程序
多线程：计算机概念，一个进程有多个线程同时运行

c#里面的多线程：
thread类是c#语言对线程对象的一个封装
为什么可以多线程呢？
- 1 多个cpu的核可以并行工作，
  4核8线程，这里的线程指的是模拟核
- 2 cpu分片，1s的处理能力分成1000份，操作系统调度着去响应不同的任务
  从宏观角度来说，感觉就是多个任务在并发执行
  从微观角度来说，一个物理cpu同一时刻只能为一个任务服务

并行:多核之间叫并行
并发：cpu分片的并发

同步异步：
同步方法：发起调用，完成后才继续下一行；非常符合开发思维，有序执行；
诚心诚意的请人吃饭，邀请nick，nick要忙一会儿，等着nick完成后，再一起去吃饭
异步方法：发起调用，不等待完成，直接进入下一行，启动一个新线程来完成方法的计算
客气一下的请人吃饭，邀请亡五，亡五要忙一会儿，你忙着我去吃饭了，你忙完自己去吃饭吧

一、异步方法

1 同步方法卡界面：主线程(UI线程)忙于计算，无暇他顾
异步多线程方法不卡界面：主线程闲置，计算任务交给子线程完成
改善用户体验，winform点击个按钮不至于卡死；
web应用发个短信通知，异步多线程去发短信；
2 同步方法慢，只有一个线程计算
异步多线程方法快，因为5个线程并发计算
12658ms 3636ms 不到4倍 CPU密集型计算(资源受限)
10126ms 2075ms 差不多5倍，也不到5倍，Sleep(资源够用)
多线程其实是资源换性能，1 资源不是无限的 2 资源调度损耗

一个订单表统计很耗时间，能不能多线程优化下性能？不能！这就是一个操作，没法并行
需要查询数据库/调用接口/读硬盘文件/做数据计算，能不能多线程优化下性能？可以，多个任务可以并行
线程不是越多越好，因为资源有限，而且调用有损耗

3 同步方法有序进行，异步多线程无序
启动无序：线程资源是向操作系统申请的，由操作系统的调度策略决定，所以启动顺序随机
同一个任务同一个线程，执行时间也不确定，CPU分片
以上相加，结束也无序
使用多线程请一定小心，很多事儿不是相当然的，尤其是多线程操作间有顺序要求的时候，
通过延迟一点启动来控制顺序？或者预计下结束顺序？这些都不靠谱！

  Action<string> action = this.DoSomethingLong;//action.Invoke("btnAsync_Click_1"); #同步方法 Invoke//action("btnAsync_Click_1");//委托自身需要的参数+2个异步参数//action.BeginInvoke("btnAsync_Click_1", null, null); #异步方法BeginInvoke

 Action<string> action = this.DoSomethingLong;IAsyncResult asyncResult = null;//是对异步调用操作的描述{//1 回调：将后续动作通过回调参数传递进去，子线程完成计算后，去调用这个回调委托AsyncCallback callback = ar =>{Console.WriteLine($"{object.ReferenceEquals(ar, asyncResult)}");Console.WriteLine($"btnAsyncAdvanced_Click计算成功了。{ar.AsyncState}。{Thread.CurrentThread.ManagedThreadId.ToString("00")}");};asyncResult = action.BeginInvoke("btnAsyncAdvanced_Click", callback, "花生");}{//2 通过IsComplate等待，卡界面--主线程在等待，边等待边提示//（ Thread.Sleep(200);位置变了，少了一句99.9999）int i = 0;while (!asyncResult.IsCompleted){if (i < 9){Console.WriteLine($"中华民族复兴完成{++i * 10}%....");}else{Console.WriteLine($"中华民族复兴完成99.999999%....");}Thread.Sleep(200);}Console.WriteLine("中华民族复兴已完成，沉睡的东方雄狮已觉醒！");}{//3 WaitOne等待，即时等待 限时等待asyncResult.AsyncWaitHandle.WaitOne();//直接等待任务完成asyncResult.AsyncWaitHandle.WaitOne(-1);//一直等待任务完成asyncResult.AsyncWaitHandle.WaitOne(1000);//最多等待1000ms，超时就不等了}{//4 EndInvoke 即时等待, 而且可以获取委托的返回值 一个异步操作只能End一次action.EndInvoke(asyncResult);//等待某次异步调用操作结束Console.WriteLine("全部计算成功了。。");}{Func<int> func = () =>{Thread.Sleep(2000);return DateTime.Now.Hour;};int iResult = func.Invoke();//22IAsyncResult asyncResult1 = func.BeginInvoke(ar =>{//int iEndResultIn = func.EndInvoke(ar);}, null);int iEndResult = func.EndInvoke(asyncResult1);//22}

二、多线程

Thread:C#对线程对象的一个封装

            {ParameterizedThreadStart method = o => this.DoSomethingLong("btnThread_Click");Thread thread = new Thread(method);thread.Start("123");//开启线程，执行委托的内容}{ThreadStart method = () =>{Thread.Sleep(5000);this.DoSomethingLong("btnThread_Click");Thread.Sleep(5000);};Thread thread = new Thread(method);thread.Start();//开启线程，执行委托的内容thread.Suspend();//暂停thread.Resume();//恢复    真的不该要的，暂停不一定马上暂停；让线程操作太复杂了thread.Abort();//线程是计算机资源，程序想停下线程，只能向操作系统通知(线程抛异常)，//会有延时/不一定能真的停下来Thread.ResetAbort();1等待while (thread.ThreadState != ThreadState.Stopped){Thread.Sleep(200);//当前线程休息200ms}2 Join等待thread.Join();//运行这句代码的线程，等待thread的完成thread.Join(1000);//最多等待1000msConsole.WriteLine("这里是线程执行完之后才操作。。。");thread.Priority = ThreadPriority.Highest;//最高优先级：优先执行，但不代表优先完成  甚至说极端情况下，还有意外发生，不能通过这个来控制线程的执行先后顺序thread.IsBackground = false;//默认是false 前台线程，进程关闭，线程需要计算完后才退出thread.IsBackground = true;//关闭进程，线程退出}{ThreadStart threadStart = () => this.DoSomethingLong("btnThread_Click");Action actionCallBack = () =>{Thread.Sleep(2000);Console.WriteLine($"This is Calllback {Thread.CurrentThread.ManagedThreadId.ToString("00")}");};this.ThreadWithCallBack(threadStart, actionCallBack);}{Func<int> func = () =>{Thread.Sleep(5000);return DateTime.Now.Year;};Func<int> funcThread = this.ThreadWithReturn(func);//非阻塞Console.WriteLine("do something else/");Console.WriteLine("do something else/");Console.WriteLine("do something else/");Console.WriteLine("do something else/");Console.WriteLine("do something else/");int iResult = funcThread.Invoke();//阻塞}{List<Thread> threads = new List<Thread>();for (int i = 0; i < 100; i++){if (threads.Count(t => t.ThreadState == ThreadState.Running) < 10){Thread thread = new Thread(new ThreadStart(() => { }));thread.Start();threads.Add(thread);}else{Thread.Sleep(200);}}}

三、线程池

.NetFramework2.0 如果某个对象创建和销毁代价比较高，同时这个对象还可以反复使用的，就需要一个池子
保存多个这样的对象，需要用的时候从池子里面获取；用完之后不用销毁，放回池子；(享元模式)
节约资源提升性能；此外，还能管控总数量，防止滥用；
ThreadPool的线程都是后台线程

线程池等待

  {ThreadPool.GetMaxThreads(out int workerThreads, out int completionPortThreads);Console.WriteLine($"当前电脑最大workerThreads={workerThreads} 最大completionPortThreads={completionPortThreads}");ThreadPool.GetMinThreads(out int workerThreadsMin, out int completionPortThreadsMin);Console.WriteLine($"当前电脑最小workerThreads={workerThreadsMin} 最大completionPortThreads={completionPortThreadsMin}");//设置的线程池数量是进程全局的，//委托异步调用--Task--Parrallel--async/await 全部都是线程池的线程//直接new Thread不受这个数量限制的(但是会占用线程池的线程数量)ThreadPool.SetMaxThreads(8, 8);//设置的最大值，必须大于CPU核数，否则设置无效ThreadPool.SetMinThreads(2, 2);Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&设置最大最小&&&&&&&&&&&&&&&&&&&&&&&&&&&");ThreadPool.GetMaxThreads(out int workerThreads1, out int completionPortThreads1);Console.WriteLine($"当前电脑最大workerThreads={workerThreads1} 最大completionPortThreads={completionPortThreads1}");ThreadPool.GetMinThreads(out int workerThreadsMin1, out int completionPortThreadsMin1);Console.WriteLine($"当前电脑最大workerThreads={workerThreadsMin1} 最大completionPortThreads={completionPortThreadsMin1}");
}{//等待ManualResetEvent mre = new ManualResetEvent(false);//false---关闭---Set打开---true---WaitOne就能通过//true---打开--ReSet关闭---false--WaitOne就只能等待ThreadPool.QueueUserWorkItem(o =>{this.DoSomethingLong("btnThreadPool_Click1");mre.Set();});Console.WriteLine("Do Something else...");Console.WriteLine("Do Something else...");Console.WriteLine("Do Something else...");mre.WaitOne();Console.WriteLine("任务已经完成了。。。");
}{//死锁：不要阻塞线程池里面的线程ThreadPool.SetMaxThreads(8, 8);ManualResetEvent mre = new ManualResetEvent(false);for (int i = 0; i < 10; i++){int k = i;ThreadPool.QueueUserWorkItem(t =>{Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId.ToString("00")} show {k}");if (k == 9){mre.Set();}else{mre.WaitOne();}});}if (mre.WaitOne()){Console.WriteLine("任务全部执行成功！");}
}

四、Task 任务

Task是.NetFramework3.0出现的，线程是基于线程池，然后提供了丰富的API

1 Task：Waitall WaitAny Delay
2 TaskFactory:ContinueWhenAny ContinueWhenAll
3 并行运算Parallel.Invoke/For/Foreach

 Console.WriteLine($"****************btnTask_Click Start {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}***************");{Task task = new Task(() => this.DoSomethingLong("btnTask_Click_1"));task.Start();}{Task task = Task.Run(() => this.DoSomethingLong("btnTask_Click_2"));}{TaskFactory taskFactory = Task.Factory;Task task = taskFactory.StartNew(() => this.DoSomethingLong("btnTask_Click_3"));}{ThreadPool.SetMaxThreads(8, 8);//线程池是单例的，全局唯一的//设置后，同时并发的Task只有8个；而且线程是复用的；//Task的线程是源于线程池//全局的，请不要这样设置！！！for (int i = 0; i < 100; i++){int k = i;Task.Run(() =>{Console.WriteLine($"This is {k} running ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");Thread.Sleep(2000);});}//假如说我想控制下Task的并发数量，该怎么做？}{{Stopwatch stopwatch = new Stopwatch();stopwatch.Start();Console.WriteLine("在Sleep之前");Thread.Sleep(2000);//同步等待--当前线程等待2s 然后继续Console.WriteLine("在Sleep之后");stopwatch.Stop();Console.WriteLine($"Sleep耗时{stopwatch.ElapsedMilliseconds}");}{Stopwatch stopwatch = new Stopwatch();stopwatch.Start();Console.WriteLine("在Delay之前");Task task = Task.Delay(2000).ContinueWith(t =>{stopwatch.Stop();Console.WriteLine($"Delay耗时{stopwatch.ElapsedMilliseconds}");Console.WriteLine($"This is ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");});//异步等待--等待2s后启动新任务Console.WriteLine("在Delay之后");//stopwatch.Stop();//Console.WriteLine($"Delay耗时{stopwatch.ElapsedMilliseconds}");}}{//什么时候能用多线程？ 任务能并发的时候//多线程能干嘛？提升速度/优化用户体验Console.WriteLine("Eleven开启了一学期的课程");this.Teach("Lesson1");this.Teach("Lesson2");this.Teach("Lesson3");//不能并发，因为有严格顺序(只有Eleven讲课)Console.WriteLine("部署一下项目实战作业，需要多人合作完成");//开发可以多人合作---多线程--提升性能TaskFactory taskFactory = new TaskFactory();List<Task> taskList = new List<Task>();taskList.Add(taskFactory.StartNew(() => this.Coding("冰封的心", "Portal")));taskList.Add(taskFactory.StartNew(() => this.Coding("随心随缘", "  DBA ")));taskList.Add(taskFactory.StartNew(() => this.Coding("心如迷醉", "Client")));taskList.Add(taskFactory.StartNew(() => this.Coding(" 千年虫", "BackService")));taskList.Add(taskFactory.StartNew(() => this.Coding("简单生活", "Wechat")));//谁第一个完成，获取一个红包奖励taskFactory.ContinueWhenAny(taskList.ToArray(), t => Console.WriteLine($"XXX开发完成，获取个红包奖励{Thread.CurrentThread.ManagedThreadId.ToString("00")}"));//实战作业完成后，一起庆祝一下taskList.Add(taskFactory.ContinueWhenAll(taskList.ToArray(), rArray => Console.WriteLine($"开发都完成，一起庆祝一下{Thread.CurrentThread.ManagedThreadId.ToString("00")}")));//ContinueWhenAny  ContinueWhenAll 非阻塞式的回调；而且使用的线程可能是新线程，也可能是刚完成任务的线程，唯一不可能是主线程//阻塞当前线程，等着任意一个任务完成Task.WaitAny(taskList.ToArray());//也可以限时等待（millisecondsTimeout）Console.WriteLine("Eleven准备环境开始部署");//需要能够等待全部线程完成任务再继续  阻塞当前线程，等着全部任务完成Task.WaitAll(taskList.ToArray());Console.WriteLine("5个模块全部完成后，Eleven集中点评");//Task.WaitAny  WaitAll都是阻塞当前线程，等任务完成后执行操作//阻塞卡界面，是为了并发以及顺序控制//网站首页：A数据库 B接口 C分布式服务 D搜索引擎，适合多线程并发，都完成后才能返回给用户，需要等待WaitAll//列表页：核心数据可能来自数据库/接口服务/分布式搜索引擎/缓存，多线程并发请求，哪个先完成就用哪个结果，其他的就不管了}{TaskFactory taskFactory = new TaskFactory();List<Task> taskList = new List<Task>();taskList.Add(taskFactory.StartNew(o => this.Coding("冰封的心", "Portal"), "冰封的心"));taskList.Add(taskFactory.StartNew(o => this.Coding("随心随缘", "  DBA "), "随心随缘"));taskList.Add(taskFactory.StartNew(o => this.Coding("心如迷醉", "Client"), "心如迷醉"));taskList.Add(taskFactory.StartNew(o => this.Coding(" 千年虫", "BackService"), " 千年虫"));taskList.Add(taskFactory.StartNew(o => this.Coding("简单生活", "Wechat"), "简单生活"));//谁第一个完成，获取一个红包奖励taskFactory.ContinueWhenAny(taskList.ToArray(), t => Console.WriteLine($"{t.AsyncState}开发完成，获取个红包奖励{Thread.CurrentThread.ManagedThreadId.ToString("00")}"));}{Task.Run(() => this.DoSomethingLong("btnTask_Click")).ContinueWith(t => Console.WriteLine($"btnTask_Click已完成{Thread.CurrentThread.ManagedThreadId.ToString("00")}"));//回调}{Task<int> result = Task.Run<int>(() =>{Thread.Sleep(2000);return DateTime.Now.Year;});int i = result.Result;//会阻塞}{Task.Run<int>(() =>{Thread.Sleep(2000);return DateTime.Now.Year;}).ContinueWith(tInt =>{int i = tInt.Result;});//Task.Run(() =>//{//    int i = result.Result;//会阻塞//});}{//假如说我想控制下Task的并发数量，该怎么做？  20个List<Task> taskList = new List<Task>();for (int i = 0; i < 10000; i++){int k = i;if (taskList.Count(t => t.Status != TaskStatus.RanToCompletion) >= 20){Task.WaitAny(taskList.ToArray());taskList = taskList.Where(t => t.Status != TaskStatus.RanToCompletion).ToList();}taskList.Add(Task.Run(() =>{Console.WriteLine($"This is {k} running ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");Thread.Sleep(2000);}));}}

五、Parallel并行编程

 {//Parallel并发执行多个Action 多线程的，//主线程会参与计算---阻塞界面//等于TaskWaitAll+主线程计算Parallel.Invoke(() => this.DoSomethingLong("btnParallel_Click_1"),() => this.DoSomethingLong("btnParallel_Click_2"),() => this.DoSomethingLong("btnParallel_Click_3"),() => this.DoSomethingLong("btnParallel_Click_4"),() => this.DoSomethingLong("btnParallel_Click_5"));}{Parallel.For(0, 5, i => this.DoSomethingLong($"btnParallel_Click_{i}"));}{Parallel.ForEach(new int[] { 0, 1, 2, 3, 4 }, i => this.DoSomethingLong($"btnParallel_Click_{i}"));}{ParallelOptions options = new ParallelOptions();options.MaxDegreeOfParallelism = 3;Parallel.For(0, 10, options, i => this.DoSomethingLong($"btnParallel_Click_{i}"));}{//有没有办法不阻塞？Task.Run(() =>{ParallelOptions options = new ParallelOptions();options.MaxDegreeOfParallelism = 3;Parallel.For(0, 10, options, i => this.DoSomethingLong($"btnParallel_Click_{i}"));});}

六、多线程异常和锁

1 多异常处理和线程取消
2 多线程的临时变量
3 线程安全和锁lock
4 await/async

 //throw new Exception("");#region 多线程异常处理{try{List<Task> taskList = new List<Task>();for (int i = 0; i < 100; i++){string name = $"btnThreadCore_Click_{i}";taskList.Add(Task.Run(() =>{if (name.Equals("btnThreadCore_Click_11")){throw new Exception("btnThreadCore_Click_11异常");}else if (name.Equals("btnThreadCore_Click_12")){throw new Exception("btnThreadCore_Click_12异常");}else if (name.Equals("btnThreadCore_Click_38")){throw new Exception("btnThreadCore_Click_38异常");}Console.WriteLine($"This is {name}成功 ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");}));}//多线程里面抛出的异常，会终结当前线程；但是不会影响别的线程；//那线程异常哪里去了？ 被吞了，//假如我想获取异常信息，还需要通知别的线程Task.WaitAll(taskList.ToArray());//1 可以捕获到线程的异常}catch (AggregateException aex)//2 需要try-catch-AggregateException{foreach (var exception in aex.InnerExceptions){Console.WriteLine(exception.Message);}}catch (Exception ex)//可以多catch  先具体再全部{Console.WriteLine(ex);}//线程异常后经常是需要通知别的线程，而不是等到WaitAll，问题就是要线程取消//工作中常规建议：多线程的委托里面不允许异常，包一层try-catch,然后记录下来异常信息，完成需要的操作}#endregion#region 线程取消{//多线程并发任务，某个失败后，希望通知别的线程，都停下来，how？//Thread.Abort--终止线程；向当前线程抛一个异常然后终结任务；线程属于OS资源，可能不会立即停下来//Task不能外部终止任务，只能自己终止自己(上帝才能打败自己)//cts有个bool属性IsCancellationRequested 初始化是false//调用Cancel方法后变成true(不能再变回去),可以重复canceltry{CancellationTokenSource cts = new CancellationTokenSource();List<Task> taskList = new List<Task>();for (int i = 0; i < 50; i++){string name = $"btnThreadCore_Click_{i}";taskList.Add(Task.Run(() =>{try{if (!cts.IsCancellationRequested)Console.WriteLine($"This is {name} 开始 ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");Thread.Sleep(new Random().Next(50, 100));if (name.Equals("btnThreadCore_Click_11")){throw new Exception("btnThreadCore_Click_11异常");}else if (name.Equals("btnThreadCore_Click_12")){throw new Exception("btnThreadCore_Click_12异常");}else if (name.Equals("btnThreadCore_Click_13")){cts.Cancel();}if (!cts.IsCancellationRequested){Console.WriteLine($"This is {name}成功结束 ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");}else{Console.WriteLine($"This is {name}中途停止 ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");return;}}catch (Exception ex){Console.WriteLine(ex.Message);cts.Cancel();}}, cts.Token));}//1 准备cts  2 try-catch-cancel  3 Action要随时判断IsCancellationRequested//尽快停止，肯定有延迟，在判断环节才会结束Task.WaitAll(taskList.ToArray());//如果线程还没启动，能不能就别启动了？//1 启动线程传递Token  2 异常抓取  //在Cancel时还没有启动的任务，就不启动了；也是抛异常，cts.Token.ThrowIfCancellationRequested}catch (AggregateException aex){foreach (var exception in aex.InnerExceptions){Console.WriteLine(exception.Message);}}catch (Exception ex){Console.WriteLine(ex.Message);}}#endregion#region 临时变量{//for (int i = 0; i < 5; i++)//{//    Task.Run(() =>//    {//        Console.WriteLine($"This is btnThreadCore_Click_{i} ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");//    });//}//临时变量问题，线程是非阻塞的，延迟启动的；线程执行的时候，i已经是5了//k是闭包里面的变量，每次循环都有一个独立的k//5个k变量  1个i变量for (int i = 0; i < 5; i++){int k = i;Task.Run(() =>{Console.WriteLine($"This is btnThreadCore_Click_{i}_{k} ThreadId={Thread.CurrentThread.ManagedThreadId.ToString("00")}");});}}#endregion#region 线程安全&lock{//线程安全：如果你的代码在进程中有多个线程同时运行这一段，如果每次运行的结果都跟单线程运行时的结果一致，那么就是线程安全的//线程安全问题一般都是有全局变量/共享变量/静态变量/硬盘文件/数据库的值，只要多线程都能访问和修改//发生是因为多个线程相同操作，出现了覆盖，怎么解决？//1 Lock解决多线程冲突//Lock是语法糖，Monitor.Enter,占据一个引用，别的线程就只能等着//推荐锁是private static readonly object，// A不能是Null，可以编译不能运行;//B 不推荐lock(this),外面如果也要用实例，就冲突了//Test test = new Test();//Task.Delay(1000).ContinueWith(t =>//{//    lock (test)//    {//        Console.WriteLine("*********Start**********");//        Thread.Sleep(5000);//        Console.WriteLine("*********End**********");//    }//});//test.DoTest();//C 不应该是string； string在内存分配上是重用的，会冲突//D Lock里面的代码不要太多，这里是单线程的Test test = new Test();string student = "水煮鱼";Task.Delay(1000).ContinueWith(t =>{lock (student){Console.WriteLine("*********Start**********");Thread.Sleep(5000);Console.WriteLine("*********End**********");}});test.DoTestString();//2 线程安全集合//System.Collections.Concurrent.ConcurrentQueue<int>//3 数据分拆，避免多线程操作同一个数据；又安全又高效for (int i = 0; i < 10000; i++){this.iNumSync++;}for (int i = 0; i < 10000; i++){Task.Run(() =>{lock (Form_Lock)//任意时刻只有一个线程能进入方法块儿，这不就变成了单线程{this.iNumAsync++;}});}for (int i = 0; i < 10000; i++){int k = i;Task.Run(() => this.iListAsync.Add(k));}Thread.Sleep(5 * 1000);Console.WriteLine($"iNumSync={this.iNumSync} iNumAsync={this.iNumAsync} listNum={this.iListAsync.Count}");//iNumSync 和  iNumAsync分别是多少   9981/9988  1到10000以内}#endregion