C#中异步多线程的常见用法

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C#中异步多线程的常见用法，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含14181字，纯文字阅读大概需要21分钟。

内容图文

先来看几个基本概念（纯属个人见解，可能不准确）：

进程：程序运行时，占用的全部运行资源的总和。

线程：线程是隶属于操作系统管理的，也可以有自己的计算资源，是程序执行流的最小单位。任何的操作都是由线程来完成的。

每个线程都在操作系统的进程内执行，而操作系统进程提供了程序运行的独立环境。

多线程：多核cpu协同工作，多个执行流同时运行，是用资源换时间。（单核cpu，不存在所谓的多线程）。

单线程应用：在进程的独立环境中只跑一个线程，所以该线程拥有独立权。

多线程应用：单个进程中会跑多个线程，它们会共享当前的执行环境（尤其是内存）。

在单核计算机上，操作系统必须为每个线程分配“时间片”来模拟并发。而在多核或多处理器计算机上，多个线程可以真正的并行执行。（可能会受到计算机上其他活动进程的竞争）。

win10上的时间片（使用微软官方小工具测得）：

C#中异步多线程的常见用法 - 文章图片

Thread

　　Thread的对象是非线程池中的线程，有自己的生命周期（有创建和销毁的过程），所以不可以被重复利用（一个操作中，不会出现二个相同Id的线程）。

Thread的常见属性：

线程一旦开始执行，IsAlive就是true，线程结束就变成false。
线程结束的条件是：线程构造函数传入的委托结束了执行。
线程一旦结束，就无法再重启。
每个线程都有一个Name属性，通常用于调试，线程的Name属性只能设置一次，以后更改会抛出异常。
静态的Thread.CurrentThread属性，会返回当前线程。

Thread的常见用法：

join

调用join方法可以等待另一个线程结束。

private void button5_Click(object sender, EventArgs e) {     
     Console.WriteLine($"===============Method  start time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},Thread ID is  {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}===================");
     //开启一个线程，构造方法可重载两种委托，一个是无参无返回值，一个是带参无返回值
     Thread thread = new Thread(a => DoSomeThing("Thread"));
     //当前线程状态
     Console.WriteLine($"thread's state is  {thread.ThreadState},thread's priority is {thread.Priority} ,thread is alived ：{thread.IsAlive},thread is background:{thread.IsBackground},thread is pool threads: {thread.IsThreadPoolThread}");
     //告知操作系统，当前线程可以被执行了。
     thread.Start();
     //阻塞当前执行线程，等待此thread线程实例执行完成。无返回值
     thread.Join(); 
     //最大等待的时间是5秒（不管是否执行完成，不再等待），返回一个bool值，如果是true,表示执行完成并终止。如果是false，表示已到指定事件但未执行完成。
     thread.Join(5000); 
     Console.WriteLine($"===============Method  end time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},,Thread ID is  {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}===================");
 }
private void DoSomeThing(string name)
 {
     Console.WriteLine($"do some thing start time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},Thread ID is  {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}");
     long result = 0;
     for (long i = 0; i < 10000 * 10000; i++)
     {
         result += i;
     }
     Console.WriteLine($"do some thing end time is {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")},Thread ID is  {Thread.CurrentThread.ManagedThreadId},is back ground: {Thread.CurrentThread.IsBackground}");
 }

注意：thread 默认是前台线程，启动后一定要完成任务的,即使程序关掉（进程退出）也要执行完。可以把thread 指定为后台线程，随着进程的退出而终止。

//false,默认是前台线程，启动后一定要完成任务的,即使程序关掉（进程退出）也要执行完。
Console.WriteLine(thread.IsBackground); 
thread.IsBackground = true;//指定为后台线程。（随着进程的退出而退出）

Sleep

Thread.Sleep()会暂停当前线程,，并等待一段时间。其实，Thread.Sleep只是放弃时间片的剩余时间，让系统重新调度并选择一个合适的线程。

在没有其他活动线程的情况下，使用Thread.Sleep(0)还是会选上自身，即连任，系统不会对其做上下文切换。

static void Main(string[] args)
{
    Stopwatch stopwatch=new Stopwatch();
    stopwatch.Start();
    Thread.Sleep(0);
    stopwatch.Stop();
    System.Console.WriteLine(stopwatch.ElapsedMilliseconds); //返回0
}

而Thread.Sleep(大于0)却让当前线程沉睡了，即使只有1ms也是沉睡了，也就是说当前线程放弃下次的竞选，所以不能连任，系统上下文必然发生切换。

阻塞

如果线程的执行由于某种原因导致暂停，那么就认为该线程被阻塞了。例如在Sleep或者Join等待其他线程结束。被阻塞的线程会立即将其处理器的时间片生成给其他线程，从此就不再消耗处理器时间。

Thread的回调用法：

Thread没有像Framework中的delegate的回调用法，如果需要回调得自动动手改造：

private void CallBack(Action action, Action calback)
{
    Thread thread = new Thread(() => { action(); calback(); });
    thread.Start();
}
//无参无返回值
CallBack(() => Console.WriteLine("好吗？"), () => Console.WriteLine("好的！"));

private Func<T> CallBackReturn<T>(Func<T> func)
{
    T t = default(T);
    Thread thread = new Thread(() =>
    {
        t = func();
    });
    thread.Start();
    return () =>
    {
        thread.Join();
        return t;
    };
}
//带返回值得用法
Func<int> func = CallBackReturn<int>(() => DateTime.Now.Second);
Console.WriteLine("线程未阻塞");
int result = func.Invoke();
Console.WriteLine("result:" + result);

ThreadPool 线程池

Thread的功能太过强大，像我这样的小白是用不好的（之前在项目中大量使用Thread的API,出现了许多意想不到的bug）。线程池中的线程在同一操作中可以被重复利用。

 //开启多线程
 ThreadPool.QueueUserWorkItem(n => DoSomeThing("ThreadPool"));

个人觉得尽量不要阻塞线程池的线程，因为线程池里的线程数量是有限的，当线程池中没有线程可用时，会出现死锁。如果非要等待，用法如下：

ManualResetEvent manualResetEvent = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(n =>
{
    DoSomethingLong("ThreadPool");
    manualResetEvent.Set();
});
//等待线程完成
manualResetEvent.WaitOne();

Task

Task是基于ThreadPool的基础上做的封装，属于线程池中的线程。

Task启动多线程的方式：

方式一：指定任务的开始时机

/// <summary>
/// 使用Task或Task<T>创建任务，需指定任务的开始时机（任务调度）。
/// </summary>
public static void Demo1()
{
    Task task = new Task(() =>
    {
        Thread.Sleep(3000); 
        Console.WriteLine($"Current thread id is {Thread.CurrentThread.ManagedThreadId}");
    });
    task.Start();//任务调度（开始任务）
    Console.WriteLine($"Current thread name is {Thread.CurrentThread.ManagedThreadId}");
    Console.WriteLine($"当前任务状态：{task.Status}");
    task.Wait(); //等待任务执行完成
    Console.WriteLine($"当前任务状态：{task.Status}");
}

方式二：一步完成多线程的创建和启动

/// <summary>
/// 使用Task.Run()方法一步完成多线程的创建和启动（当前线程立即准备启动任务）。
/// <remark>
/// 如果不需要对任务的创建和调度做更多操作,Task.Run()方法是创建和启动任务的首选方式。
/// </remark>
/// </summary>
public static void Demo2()
{
    Task task = Task.Run(() => { Thread.Sleep(3000); Console.WriteLine($"Current thread id is {Thread.CurrentThread.ManagedThreadId}"); });
    task.Wait(); //等待，直到任务完成
}

方式三：需要想多线程任务传递状态参数

/// <summary>
/// Task和Task<TResult>都有静态属性Factory，它返回默认的实例TaskFactory.
/// 使用Task.Factory.StartNew()方法也可以一步完成任务的创建和启动。
/// 当前需要向任务传递一个状态（参数）。可以使用此方法。
/// </summary>
public static void Demo3()
{
    Task[] tasks = new Task[10];
    for (int i = 0; i < tasks.Length; i++)
    {
        tasks[i] = Task.Factory.StartNew((obj) =>
        {
            CustomData data = obj as CustomData;
            data.ThreadId = Thread.CurrentThread.ManagedThreadId;
        }, new CustomData { CreationTime = DateTime.Now.Ticks, Index = i});
    }
    //以阻塞当前线程的方式，等待所以子线程的完成
    Task.WaitAll(tasks);
    foreach (var task in tasks)
    {
        //通过任务的AsyncState属性，可以获取任务状态（提供给任务的参数).
        var data = task.AsyncState as CustomData;
        Console.WriteLine(JsonConvert.SerializeObject(data));
    }
}
//Task.Factory.StartNew() 调用无返回值的任务
//Task<TResult>.Factory.StartNew() 调用有返回值的任务

Task<TResult>

public static void Demo4()
{
    Task<Double>[] tasks = {
Task<Double>.Factory.StartNew(() => DoComputation(1.0)),
Task<Double>.Factory.StartNew(() => DoComputation(100.0)),
Task<Double>.Factory.StartNew(() => DoComputation(1000.0)) };
    var results = new Double[tasks.Length];
    Double sum = 0;
    for (int i = 0; i < tasks.Length; i++)
    {
        //Task<TResult>.Result属性包含任务的计算结果，如果在任务完成之前调用，则会阻塞线程直到任务完成
        results[i] = tasks[i].Result; 
        Console.Write("{0:N1} {1}", results[i],
                          i == tasks.Length - 1 ? "= " : "+ ");
        sum += results[i];
    }
    Console.WriteLine("{0:N1}", sum);
}
private static Double DoComputation(Double start)
{
    Double sum = 0;
    for (var value = start; value <= start + 10; value += .1)
        sum += value;
    return sum;
}

Task的常用API

WaitAny和WaitAll，会阻塞当前线程（主线程）的执行：

List<Task> tasks = new List<Task>();
tasks.Add(Task.Run(() => DoSomeThing("Task1")));
tasks.Add(Task.Run(() => DoSomeThing("Task2")));
tasks.Add(Task.Run(() => DoSomeThing("Task3")));
//阻塞当前线程的执行,等待任意一个子线程任务完成后继续往下执行
Task.WaitAny(tasks.ToArray());
//阻塞当前线程的执行,等待所有子线程任务完成后继续往下执行
Task.WaitAll(tasks.ToArray());

WhenAll和WhenAny,是通过返回一个Task 对象的方式，来达到非阻塞式的等待

//不阻塞当前线程的执行,等待所有子线程任务完成后,异步执行后续的操作
Task.WhenAll(tasks).ContinueWith(t =>
{
    Console.WriteLine($"不阻塞，{Thread.CurrentThread.ManagedThreadId}");
});

//工厂模式的实现
Task.Factory.ContinueWhenAll(tasks.ToArray(), s =>
{
Console.WriteLine("不阻塞" + s.Length);
});

ContinueWith，是一个实例方式，并且返回Task实例，所以可以使用这种链式结构来完成按顺序执行。

public static void Demo8()
{
    var task = Task.Factory
        .StartNew(() => { Console.WriteLine("1"); return 10; })
        .ContinueWith(i => { Console.WriteLine("2"); return i.Result + 1; })
        .ContinueWith(i => { Console.WriteLine("3"); return i.Result + 1; });
    Console.WriteLine(task.Result);
}

控制线程数量的使用，(核心思想来自别人，我感觉控制的很好):

/// <summary>
/// 线程数量的控制
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Test(object sender, EventArgs e)
{
    //完成10000个任务，但只要11个线程。
    List<int> intList = new List<int>();
    for (int i = 0; i < 10000; i++)
    {
        intList.Add(i);
    }
    Action<int> action = i =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(new Random(i).Next(100, 300));
    };
    List<Task> tasks = new List<Task>();
    foreach (var item in intList)
    {
        int i = item;
        tasks.Add(Task.Run(() => action(i)));
        //当已使用了11个线程的时候，即时释放已完成的线程。
        if (tasks.Count > 10)
        {
            Task.WaitAny(tasks.ToArray());
            tasks = tasks.Where(n => n.Status != TaskStatus.RanToCompletion).ToList();
        }
    }
    Task.WaitAll(tasks.ToArray());
}

注意：应当避免在子线程委托的内部直接使用主线程变量（闭包的弊端问题）

 public static void Demo5()
 {
     Task[] taskArray = new Task[10];
     for (int i = 0; i < taskArray.Length; i++)
     {
         taskArray[i] = Task.Factory.StartNew(() =>
         {
             //当您使用lambda表达式创建委托时，虽然可以访问变量范围内可见的所有变量。
             //但是在某些情况下（最明显的是在循环中），lambda不能像预期的那样捕获变量
             //(本例中，它只能捕获最后一个值，而不每次迭代的值)。 
             //因为任务的运行时机不确定。可以通过传递参数的方式，避免此问题的发生。
             Console.WriteLine(i);//输出10个10
         });
     }
     Task.WaitAll(taskArray);
 }

创建分离的子任务

　　在父任务中创建子任务，如果未指定AttachedToParent选项时，子任务不会与父任务同步。

public static void Demo9()
{
    //创建父任务
    var outer = Task.Run(() =>
    {
        Console.WriteLine("父任务开始启动！");
        //创建子任务
        var child = Task.Run(() =>
        {
            Thread.SpinWait(5000000);
            Console.WriteLine("分离的任务完成");
        });
    });
    outer.Wait(); //父任务不会等待子任务的完成
    Console.WriteLine("父任务完成.");
}

当在任务中运行的代码使用AttachedToParent选项创建新任务时，新任务称为父任务的附加子任务。可以使用AttachedToParent选项来表达结构化任务并行性，因为父任务隐式等待所有附加的子任务完成。

 public static void Demo10()
 {
     var parent = Task.Factory.StartNew(() => {
         Console.WriteLine("Parent task beginning.");
         for (int i = 0; i < 10; i++)
         {
             Task.Factory.StartNew((x) => {
                 Thread.SpinWait(5000000);
                 Console.WriteLine("Attached child #{0} completed.",x);
             }, i, TaskCreationOptions.AttachedToParent);  
         }
     });
     parent.Wait();
     Console.WriteLine("Parent task completed.");
 }

注意：如果父任务启动DenyChildAttach选项，子任务即时启用AttachedToParent选项也不会附加到父任务。

Parallel parallel为并行计算，主线程也参与计算

 //Parallel.For:
public static void Main(string[] args)
 {
     //计算目录的大小
     long totalSize = 0;
     String[] files =Directory.GetFiles(@"C:\Users\Administrator\Desktop");
     Parallel.For(0, files.Length,
                  index => {
                      FileInfo fi = new FileInfo(files[index]);
                      long size = fi.Length;
                      Interlocked.Add(ref totalSize, size);  //将两个64位整数相加，并用和替换第一个整数，作为
                  });
     Console.WriteLine("{0:N0} files, {1:N0} bytes", files.Length, totalSize); 
 }

//旋转图片 
static void Main(string[] args)
 {
     // A simple source for demonstration purposes. Modify this path as necessary.
     string[] files = Directory.GetFiles(@"C:\Users\Administrator\Desktop\test");
     string newDir = @"C:\Users\Administrator\Desktop\test\Modified";
     if (!Directory.Exists(newDir))
         Directory.CreateDirectory(newDir);
     // Method signature: Parallel.ForEach(IEnumerable<TSource> source, Action<TSource> body)
     Parallel.ForEach(files, (currentFile) =>
     {
         // The more computational work you do here, the greater 
         // the speedup compared to a sequential foreach loop.
         string filename = Path.GetFileName(currentFile);
         var bitmap = new Bitmap(currentFile);
         bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
         bitmap.Save(Path.Combine(newDir, filename));
         // Peek behind the scenes to see how work is parallelized.
         // But be aware: Thread contention for the Console slows down parallel loops!!!
         Console.WriteLine($"Processing {filename} on thread {Thread.CurrentThread.ManagedThreadId}");
         //close lambda expression and method invocation
     });
 }

分区局部变量

 static void TestParallForeach()
 {
     int[] array = Enumerable.Range(1, 100).ToArray();
     long totalNum = 0;
     //int 为集合元素类型
     //long 为分区局部变量类型
     Parallel.ForEach<int, long>(array, //源集合
         () => 0, //初始化局部分区变量，每个分区执行一次
         (index, state, subtotal) => //每次迭代的时候执行
         {
             subtotal += index; //修改分区局部变量
             return subtotal; //传递给当前分区的下一次迭代
         },
         //每个分区结束的时间执行,并将该分区最后一次迭代的局部分区变量传递过来。
         (finalTotal) => Interlocked.Add(ref totalNum, finalTotal)
         );
     /*重载方式：public static ParallelLoopResult ForEach<TSource, TLocal>(IEnumerable<TSource> source, 
     Func<TLocal> localInit, Func<TSource, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally);
     TSource:源数据类型。 source:源数据，必须实现 IEnumerable<T>接口。
     TLocal:局部分区变量类型。localInit：初始化局部分区变量的函数。每个分区都是执行此函数一次。
     body:并行循环的每次迭代都是调用此方法。
     body.TSource:当前元素。body.ParallelLoopState:ParallelLoopState类型的变量，可用来检索循环的状态。
     body.TLocal.1:局部分区变量。
     body.TLocal.2:返回值。将其传递给特定分区循环的下一个迭代。
     localFinally:每个分区的循环完成时调用此委托。*/
     Console.WriteLine(totalNum);

内容总结

以上是互联网集市为您收集整理的C#中异步多线程的常见用法全部内容，希望文章能够帮你解决C#中异步多线程的常见用法所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/597478.html

来源：【匿名】

【上一篇】浅谈C#中常见的委托＜Func,Action,Predicate＞【下一篇】assemblyinfo.csC#Assembly类访问程序集信息

更多 ►

【C#中异步多线程的常见用法】教程文章相关的互联网学习教程文章

一、前言网上有许多的多线程断点续传操作，但总是写的很云里雾里，或者写的比较坑长。由于这几个月要负责公司的在线升级项目，所以正好用到代码如下： 1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.IO;6using System.Threading;7using System.Threading.Tasks;8 9namespace ConsoleStream10{11class Program12 {13staticvoid Main(string[] args)14 ...

说说C# 多线程那些事-线程基础【代码】【图】

我第一次接触“线程”的概念时，觉得它深奥难懂，看了好多本书，花了很长时间才领悟到它的真谛。现在我就以一个初学者的心态，把我所理解的“多线程”描述给大家。这一次是系列文章，比较完整的展示与线程相关的基本概念。希望对初学者有所帮助。如果你是高手，请你别继续看，会浪费你宝贵的时间。一、基本概念什么是进程？当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。而一个进程...

c# 多线程和异步【代码】

有时候需要多线程来运行处理后端和UI的更新。通常用 ((Action)delegate(){if (isBussy) { return; }isBussy = true;while (true){//code long time task.................Dispatcher.BeginInvoke((Action)(delegate(){btnStart.Content = DateTime.Now.ToString();}));Thread.Sleep(300);}isBussy = false;}).BeginInvoke(null, null);原文：https://www.cnblogs.com/wgscd/p/9259742.html

C#多线程（三）【图】

一、线程同步概述在多线程程序中，当存在共享变量和抢占资源的情况时，需要使用线程同步机制来防止发生这些冲突，这样才能保证得到可预见的结果，也就是线程安全的。否则就会出现不可预知的结果产生线程不安全问题。特别是在访问同一个数据的时候最为明显。主要通过以下四个方式进行：简单阻塞：让一个线程等待另一个线程执行结束或者等待一段时间而阻塞执行，使用Sleep、Join、Task.Wait这几个方式构成目的Sleep阻止给定的时间周期...

C# 多线程同步和线程通信【代码】【图】

多线程通信1. 当线程之间有先后的依赖关系时，属于线程之间的通信问题。也就是后一个线程要等待别的一个或多个线程全部完成，才能开始下一步的工作。可以使用：WaitHandle Class　　WaitHandle类作为基类来使用的，它允许多个等待操作。这个类封装了win32的同步处理方法。WaitHandle对象通知其他的线程它需要对资源排他性的访问，其他的线程必须等待，直到WaitHandle不再使用资源和等待句柄没有被使用。下面是从它继承来的几个类：...

C# 实现多线程的同步方法详解

http://www.cnblogs.com/xugang/archive/2011/03/20/1989782.html原文：http://www.cnblogs.com/wanxun1987/p/3575642.html

C# 多线程task

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace 多线程Task { class Program { static void Main(string[] args) { Task task = new Task( () => { for (int i = 0; i < 10; i++) { ...

《C#多线程编程实现方式》【代码】

一、使用线程的理由1、可以使用线程将代码同其他代码隔离，提高应用程序的可靠性。2、可以使用线程来简化编码。3、可以使用线程来实现并发执行。二、基本知识1、进程与线程：进程作为操作系统执行程序的基本单位，拥有应用程序的资源，进程包含线程，进程的资源被线程共享，线程不拥有资源。2、前台线程和后台线程：通过Thread类新建线程默认为前台线程。当所有前台线程关闭时，所有的后台线程也会被直接终止，不会抛出异常。3、挂...

C#多线程传参

方法1：public void Execute(string device,string type){ object[] paras = new object[] { device,type }; new Thread(new ParameterizedThreadStart(tExecute)).Start(paras);} private void tExecute(object para){ object[] paras = (object[])para; string device = (string)paras[0]; string type=(string)paras[1]; 。。。}方法2：public void Execute(intx,inty){ My m = new My(); m.x = x; m...

lock与C#多线程【代码】

lock与C#多线程</strong> keyword marks a statement block as a critical section by obtaining the mutual-exclusion lock for a given object, executing a statement, and then releasing the lock.">lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。简单讲就类似于你去银行办理业务，一个柜台一次只能操作以为客户，而如果你要到这个柜台办理业务就必须等前面的人的业务完成，而彼此...

c#多线程 Invoke方法的使用

在多线程编程中，我们经常要在工作线程中去更新界面显示，而在多线程中直接调用界面控件的方法是错误的做法，Invoke 和 BeginInvoke 就是为了解决这个问题而出现的，使你在多线程中安全的更新界面显示。正确的做法是将工作线程中涉及更新界面的代码封装为一个方法，通过 Invoke 或者 BeginInvoke 去调用，两者的区别就是一个导致工作线程等待，而另外一个则不会。而所谓的“一面响应操作，一面添加节点”永远只能是相对的，使 UI 线...

C#多线程操作界面控件的解决方案

在使用VS2005的时候，如果你从非创建这个控件的线程中访问这个控件或者操作这个控件的话就会抛出这个异常。这是微软为了保证线程安全以及提高代码的效率所做的改进，但是也给大家带来很多不便。其实解决这个问题有两种方法：一，是通过设置System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;在你的程序初始化的时候设置了这个属性，而且在你的控件中使用的都是微软Framework类库中的控件的话，系统就不会再抛...

C#多线程线程的启动【代码】

在实例化Thread的实例，需要提供一个委托，在实例化这个委托时所用到的参数是线程将来启动时要运行的方法。在.net中提供了两种启动线程的方式，一种是不带参数的启动方式，另一种是带参数的启动的方式。不带参数的启动方式如果启动参数时无需其它额外的信息，可以使用ThreadStart来实例化Thread，如下面的代码: 1using System;2using System.Collections.Generic;3using System.Text;4using System.Threading;5 6namespace Console...

c#多线程更新窗口(winform)GUI的数据

1. 在.net framwork 2.0中，可以通过以下代码来实现:1 2 3 4 5 6 7 8 9 10 11 12 privatedelegatevoidSetControlPropertyThreadSafeDelegate(Control control, stringpropertyName, objectpropertyValue);publicstaticvoidSetControlPropertyThreadSafe(Control control, stringpropertyName, objectpropertyValue){ if(control.InvokeRequired) { control.Invoke(newSetControlPropertyThreadSafeDelegate(SetControlPropert...

C#并行和多线程编程 3——认识和使用Task【代码】【图】

对于多线程，我们经常使用的是Thread。在我们了解Task之前，如果我们要使用多核的功能可能就会自己来开线程，然而这种线程模型在.net 4.0之后被一种称为基于“任务的编程模型”所冲击，因为task会比thread具有更小的性能开销，不过大家肯定会有疑惑，任务和线程到底有什么区别呢？任务和线程的区别：1、任务是架构在线程之上的，也就是说任务最终还是要抛给线程去执行。2、任务跟线程不是一对一的关系，比如开10个任务并不是说会开...

C# - 技术教程分类

C# 教程 C# 简介 C# 环境 C# 程序结构 C# 基本语法 C# 数据类型 C# 类型转换 C# 变量 C# 常量 C# 运算符 C# 判断 C# 循环 C# 封装 C# 方法 C# 可空类型 C# 数组（Array） C# 字符串（String） C# 结构体（Struct） C# 枚举（Enum） C# 类（Class） C# 继承 C# 多态性 C# 运算符重载 C# 接口（Interface） C# 命名空间（Namespace） C# 预处理器指令 C# 异常处理 C# 特性（Attribute） C# 反射（Reflection） C# 属性（Property） C# 索引器（Indexer） C# 委托（Delegate） C# 事件（Event） C# 集合（Collection） C# 泛型（Generic） C# 匿名方法 C# 不安全代码 C# 多线程 c# 全部

C# - 最热教程

c#编程连接oracle数据库无法加载DLL(oc...一个适合新手C#程序员编写练习的小项目...C# 异步UDP发送接收数据 C#程序执行时间长和慢查询解决：线程并...c# aspose操作word文档 C#继承讲解以及对象的创建 jquery+ajax+C#实现无刷新操作数据库数...C#精髓 GridView72大绝技学习gridview...c# static的全部用法收集整理 js模拟实现类似c#下的hashtable的简单功...

首页 / C# / C#中异步多线程的常见用法

C#中异步多线程的常见用法

内容导读

内容图文

Thread

join

Sleep

阻塞

内容总结

内容备注

内容手机端

【C#中异步多线程的常见用法】教程文章相关的互联网学习教程文章

C#基础-FileStream实现多线程断点续传【代码】

说说C# 多线程那些事-线程基础【代码】【图】

c# 多线程和异步【代码】

C#多线程（三）【图】

C# 多线程同步和线程通信【代码】【图】

C# 实现多线程的同步方法详解

C# 多线程task

《C#多线程编程实现方式》【代码】

C#多线程传参

lock与C#多线程【代码】

c#多线程 Invoke方法的使用

C#多线程操作界面控件的解决方案

C#多线程线程的启动【代码】

c#多线程更新窗口(winform)GUI的数据

C#并行和多线程编程 3——认识和使用Task【代码】【图】

多线程 - 相关标签

C# - 技术教程分类

C# - 最新教程

C# - 最热教程