异步线程Task

最新推荐文章于 2024-07-05 17:25:50 发布
最新推荐文章于 2024-07-05 17:25:50 发布
阅读量4.7k 收藏 11
点赞数 2
分类专栏： 前端 文章标签： c# asp.net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43533974/article/details/110058714
版权

异步Async

并行，一般指并行计算，是说同一时刻有多条指令同时被执行，这些指令可能执行于同一CPU的多核上，或者多个CPU上，或者多个物理主机甚至多个网络中。

多线程，一般指同一进程中多个线程（包含其数据结构、上下文与代码片段）协作运行。在多核计算机中多个线程将有机会同时运行于多个核上，如果线程中进行的是计算，则行成并行计算。

异步，与同步相对应，是指呼叫另一操作后，不等待其结果，继续执行之后的操作，若之后没有其他操作，当前线程将进入睡眠状态，而CPU时间将有机会切至其他线程。在异步操作完成后通过回调函数的方式获取通知与结果。异步的实现方式有多种，如多线程与完成端口。多线程将异步操作放入另一线程中运行，通过轮询或回调方法得到完成通知；完成端口，由操作系统接管异步操作的调度，通过硬件中断，在完成时触发回调方法，此方式不需要占用额外线程。 阻塞

异步特点：

1异步不会造成阻塞

2异步可以启用额外的线程去执行任务。

3异步并不会缩短任务的时间

Stopwatch时间统计类

  Stopwatch watch = new Stopwatch();
  watch.Start();
  watch.Stop();
  watch.ElapsedMilliseconds//执行事件

异步方法调用

Console.WriteLine("****************异步调用开始**********************");
    for (int i = 0; i < 5; i++)
       {
          string name = string.Format("异步调用{0}", i);
          DoHandler method = DoSomething;
          method.BeginInvoke("异步调用", null, null);
       }
Console.WriteLine("****************异步调用结束**********************");

异步方法（含返回值）调用

   //子线程中使用返回值
    Console.WriteLine("****************异步待返回值进阶调用开始**********************");
    Func<string, long> method = DoSomethingReturn;
    //主线程中使用返回值
    IAsyncResult result = method.BeginInvoke("异步带返回值调用", t =>
    {
       long iresult = method.EndInvoke(t);
       Console.WriteLine("这里是异步返回值，当前线程={0},计算结果是{1}", Thread.CurrentThread.ManagedThreadId, iresult);
            
    }, null);

异步回调函数

  Console.WriteLine("****************异步进阶调用开始**********************");
            for (int i = 0; i < 5; i++)
            {
                string name = string.Format("异步调用{0}", i);
                DoHandler method = DoSomething;
                AsyncCallback callback = t => Console.WriteLine("当前完成的线程是ID={0},状态参数：{1}", Thread.CurrentThread.ManagedThreadId, t.AsyncState);
                //关注参数
                //参数2：回调函数
                //参数3：回调获得
                IAsyncResult result = method.BeginInvoke(name, callback, "Admin");
 
            }
 Console.WriteLine("****************异步进阶调用结束**********************");

主线程等待异步结果

方式一：

	result.AsyncWaitHandle.WaitOne(-1);//线程一直等待

方式二：

	while (!result.IsCompleted)//判断是否结束
     {
         Thread.Sleep(100);
         Console.WriteLine("请继续等待...");//类似进度条
      }

方式三：

    method.EndInvoke(result)

主线程等待就相当于程序的阻塞。

异步的优缺点：

因为异步操作无须额外的线程负担，并且使用回调的方式进行处理，在设计良好的情况下，处理函数可以不必使用共享变量（即使无法完全不用，最起码可以减少 共享变量的数量），减少了死锁的可能。当然异步操作也并非完美无暇。编写异步操作的复杂程度较高，程序主要使用回调方式进行处理，与普通人的思维方式有些 初入，而且难以调试。

适用范围：

1.在执行I/O操作时

2.网络读写 调用接口

3.数据库的操作

4.WebService

对于需要长时间CPU运算的场合，图形处理，算法执行不适合使用异步。

但是往往由于使用多线程编程的简单和符合习惯，所以很多人往往会使用线程来执行耗时较长的I/O操作，也导致很多人就误认为异步==多线程

总结：需要耗时操作的尽量都使用异步执行。

多线程

操作系统的进程和线程，线程就是围绕进程的一个子单元。

理解多线程

例 1
界面上点击某个按钮后，需要执行一个非常耗时的操作，如果不使用多线程，就只能傻等操作返回。
使用多线程，点击按钮之后，开辟1个新线程后台去执行这个耗时操作，前台界面继续执行其他菜单目录，录入数据等。

例 2
有个操作，1个线程需要20分钟完成，现在的多核cpu，可以真正同一时刻运行多个线程。
假设是双核cpu，同一时刻运行2个线程，操作就只需要10分钟可以完成。

多线程优点：

1提高应用程序执行效率【例1】

2提高CPU利用率【例2】

线程的数量

理想的线程数量<=CPU核心数量

Thread类

Thread thread = new Thread(SayHi);
thread.Start();

线程的挂起

Thread.Sleep(1000)；

线程的阻塞

Thread.Join();

示例：

  for (var i = 0; i < 5; i++)
            {
                Thread th1 = new Thread(DoSomething);
                th1.Start();
                th1.Join();
            }

阻塞后，各线程会依次执行。

线程终止，不推荐使用，不安全不可控。

Thread.Abort();

前台线程、后台线程

Thread thread = new Thread(() =>
{
    // 默认为 False
    Console.WriteLine(Thread.CurrentThread.IsBackground);
});
// 可以设置为后台线程
//thread.IsBackground = true;
thread.Start();
thread.Join();

[复制代码](javascript:void(0)😉

.Net的公用语言运行时（Common Language Runtime，CLR）能区分两种不同类型的线程：前台线程和后台线程。这两者的区别就是：应用程序必须运行完所有的前台线程才可以退出；而对于后台线程，应用程序则可以不考虑其是否已经运行完毕而直接退出，所有的后台线程在应用程序退出时都会自动结束。

一般后台线程用于处理时间较短的任务，如在一个Web服务器中可以利用后台线程来处理客户端发过来的请求信息。而前台线程一般用于处理需要长时间等待的任务，如在Web服务器中的监听客户端请求的程序，或是定时对某些系统资源进行扫描的程序。

重要性

（1）有前台，不关闭
如果线程为前台线程，可能导致UI线程已关闭，但实际还有前台线程暗地里运行，所以程序并没有真正关闭。
（2）无前台，全关闭
当然也要注意，如果所有前台线程都关闭，后台线程会自动关闭，后台线程的代码逻辑可能没执行完就终止了。

线程传递参数

1使用ParameterizedThreadStart委托

注意：此处只能接受object类型参数，因为Thread中只接受ThreadStart委托，而该委托是一个无参无返回值的。所以此处使用ParameterizedThreadStart。

     ParameterizedThreadStart pts1 = DoSomething;
     Thread thread = new Thread(pts1);
     object name = "线程参数";
     thread.Start(name);

在线程执行过程中，该参数需要使用需要这是一个只读属性的对象

   static readonly object obj = new object();
   public static void DoSomething(string name)
        {
            Console.WriteLine("线程{0}启动", Thread.CurrentThread.ManagedThreadId);
            Stopwatch sw = new Stopwatch();
            sw.Start();
            long result = 0;
            for (int i = 0; i < 1000000000; i++)
            {
                result += i;
            }
            Thread.Sleep(2000);
            sw.Stop();
            Console.WriteLine("任务名称={3},当前线程={0},计算结果是{1},总耗时:{2}", Thread.CurrentThread.ManagedThreadId, result, sw.ElapsedMilliseconds, obj.ToString());
        }

2使用lambda传递参数(推荐)

 string hi = "张三";
 Thread thread = new Thread(() =>
 {
     DoSomething(hi);
 });
 thread.Start();

线程异常

注意:只要有线程抛出异常，整个程序就会停止。所以，异常必须处理。

对创建线程try catch没用，需要对线程中调用的函数添加异常处理代码

static void Main(string[] args)
{
    try // 无用的 try catch
    {
        Thread thread = new Thread(SayHi);
        thread.Start();
    }
    catch (Exception ex)
    {
        // 不会打印错误
        Console.WriteLine(ex.ToString());
    }
}
//正确
static void Main(string[] args)
{
    Thread thread = new Thread(SayHi);
    thread.Start();
    thread.Join();
}
static void SayHi()
{
    try
    {
        Console.WriteLine("hi");
        throw new Exception("error");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

线程安全

试试下列代码：

static void Main(string[] args)
{
    Thread thread = new Thread(
        () => { Check("张三"); });
    Thread thread2 = new Thread(
        () => { Check("李四"); });
    thread.Start();
    thread2.Start();
    thread.Join();
    thread2.Join();
}
static void Check(string name)
{
    User.Name = name;
    string format = @"{0} = {1}";
    for (int i = 0; i < 10; i++)
    {
        string s = string.Format(format, name, User.Name);
        Console.WriteLine(s);
        Thread.Sleep(10);
    }
}
public class User
{
    public static string Name { get; set; }
}

张三等于了李四

原因：User.Name是静态属性，也就是共享资源，多个线程访问共享资源，需要对共享资源做同步处理。

如何解决：

创建一个只读对象对对象处理使用lock（锁操作）

基本含义: lock就是把一段代码定义为临界区，所谓临界区就是同一时刻只能有一个线程来操作临界区的代码，当一个线程位于代码的临界区时，另一个线程不能进入临界区，如果 试图进入临界区，则只能一直等待（即被阻止），直到已经进入临界区的线程访问完毕，并释放锁旗标

static readonly object obj = new object();
// -------------------------
lock (obj)
{
    User.Name = name;
    string format = @"{0} = {1}";
    for (int i = 0; i < 10; i++)
    {
        string s = string.Format(format, name, User.Name);
        Console.WriteLine(s);
        Thread.Sleep(10);
    }
}

多线程的缺点

1线程占用一定资源，比如内存，CPU；创建和销毁操作都比较昂贵

2线程调度器要管理线程

3大量的创建线程，导致内存不够用，线程调度器繁忙。

4当多个线程竞争同一个静态资源时，会造成死锁。

线程池

由于线程的创建和销毁时比较昂贵的操作，所以在ASP.NET中自己设定了一个线程池，由底层进行统一调配。

线程池思想：事先创建好几个对象，需要就从池中分配，用完就返回池中

注意：

（1）线程池，只适合短时操作，不要阻塞线程池线程
（2）线程池，线程是后台线程
（3）线程池的线程数量有上限
（4）ASP.NET 使用自己的线程池

优缺点

（1）电脑的内存是有限的，每个线程，都会占用内存，如果并发数量很多，内存会爆掉。
（2）使用线程池，当并发超过一定数量，则会排队，所以，并行的请求处理时间会被延长。

用法：

ThreadPool.QueueUserWorkItem((obj) =>
 {
      DoSomething();
      Console.WriteLine(obj);

},"admin");

多线程和异步的区别

多线程是对cpu剩余劳动力的压榨，是一种技术，强调的是并发。

异步强调的是非阻塞，是一种编程模式（pattern），主要解决了UI响应被阻塞的问题，可借助线程技术或者硬件本身的计算能力解决。

背景：作为一个北漂，准备结束北漂生涯，谋划如何搬家。其余家当都变买了，就剩下有一辆小轿车，和一辆摩托车需要带回家。

  1. 阻塞式编程：先开其中一辆回去，再回来开另一辆车回去。

  2. 传统异步式编程：摩托车办理快递，我开汽车回去。注意，快递公司派件（回调）时我不一定已经开车到家，如果必须本人签收，就比较麻烦了。----此种通过回调进行异步编程的方式，没法编写符合思维顺序的代码。

  3. 基于多线程的异步编程：我获得了瞬间移动的超能力（cpu计算速度提升），以毫秒级的速度在汽车与摩托车之间切换驾驶。汽车（主线程）上有车载电话，可以使用处理其它事情。----期间频繁的上下文切换，会造成额外的损耗，造成反应能力比较差，只能开到60迈。

4.并行编程：我获得了分身的超能力（多核cpu的出现），两个我同时开两辆车回家。----充分发挥了cpu的能力，没有额外切换上下文的损耗，精力充沛，在120的时速狂飙。

Task任务

任务是什么

System.Threading.Tasks.Task,任务代表了一个异步操作。

任务非常强大，极大的简化了异步编程，并且能带来显著的性能提升。

举个简单例子，执行一个操作，我们要查询两张表的数据，我们创建两个任务分别各自查询一张表，是不是快些呢？

任务的线程是后台线程

本质上讲，任务就是一个线程池的增强版API

线程池的缺点

1线程池获取结果并不方便

2异步处理不方便

3连续的异步操作不方便

目的：

场景1:3个并发请求，通过3个接口获取数据，我们希望得到所有接口的数据进行下一步业务处理。

场景2:3个并发请求，只要其中某一个完成了，就触发一个事件结果。

任务的创建

1.构造函数创建

static void Main(string[] args)
{
    Task task = new Task(() =>
    {
        // True 线程池线程
        Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread);
    });
    task.Start();
    Console.ReadLine();
}

2.Task.Factory.StartNew创建

static void Main(string[] args)
{
    Task.Factory.StartNew(() =>
    {
        // True 线程池线程
        Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread);
    });
    Console.ReadLine();
}

注意：任务工厂模式下，任务会立即调用执行。

3.不使用线程池设置

static void Main(string[] args)
{
    Task task = new Task(() =>
    {
        // False 不使用线程池
        Console.WriteLine(Thread.CurrentThread.IsThreadPoolThread);
    }, TaskCreationOptions.LongRunning);
    task.Start();
    Console.ReadLine();
}

获取任务返回值

Task<string> task = new Task<string>(() =>
{
    DoSomething();
    return "此处为执行完成的结果";


});
task.Start();
Console.WriteLine(task.Result);

任务的回调

task.ContinueWith

（1）支持1个 task 接多个ContinueWith
（2）ContinueWith返回下一代 task，下一代可以继续ContinueWith

  Task<string> task = new Task<string>(() =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
        return "boy,";
    });
    task.ContinueWith((t) =>
    {
        Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
        Console.WriteLine(t.Result + "come on.");
    });
    task.Start();
    Console.ReadLine();

Task的线程等待和延续

Task下的线程等待和延续主要有以下几类：

Wait

针对单个Task的实例，可以让某一个线程进入等待。

WaitAny

执行的所有线程中只要有一个线程结束，主线程就就执行，否则就卡主

    Stopwatch sw = new Stopwatch();
            sw.Start();
            Console.WriteLine("开始了，当前主线程是:{0}", Thread.CurrentThread.ManagedThreadId);
            List<Task> taskList = new List<Task>();
            Task t1 = new Task(() =>
            {
                Console.WriteLine("我是第一个任务");
                Console.WriteLine("1号开始了，当前1号线程是:{0}", Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(3000);
                Console.WriteLine("1号任务执行完成");
               
            });

            taskList.Add(t1);
            Task t2 = new Task(() =>
            {
                Console.WriteLine("我是第二个任务");
                Console.WriteLine("2号开始了，当前2号线程是:{0}", Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(6000);
                Console.WriteLine("2号任务执行完成");
            });
            
            taskList.Add(t2);
            Task t3 = new Task(() =>
            {
                Console.WriteLine("我是第三个任务");
                Console.WriteLine("3号开始了，当前3号线程是:{0}", Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(8000);
                Console.WriteLine("3号任务执行完成");
            });
            taskList.Add(t3);
            t1.Start();
            t2.Start();
            t3.Start();
            Task.WaitAny(taskList.ToArray());
            
            Console.WriteLine("全部执行完成了,执行时间{0}，当前ID是：{1}",sw.ElapsedMilliseconds,Thread.CurrentThread.ManagedThreadId);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wSJTfDct-1606188603611)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201116161014828.png)]

WatiAll

表示任务列表中所有的任务都已经结束后，主线程恢复。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bNtZGowy-1606188603613)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20201116161212151.png)]

WhenAny

表示任务列表中任何一个任务结束后，配合ContinueWith进行回调触发。

WhenAll

表示任务列表中所有任务都结束后，配合ContinueWith进行回调触发。

注意：WhenAny和WhenAll,都是开启一个新线程执行，不卡顿主线程。

TaskFactory

TaskFactory可以开启线程，当然也对应的线程的等待和延续。

ContinueWhenAny:等价于Task的WhenAny+ContinueWith

ContinueWhenAll:等价于Task的WhenAll+ContinueWith

1.ContinueWhenAny

Task.Factory.ContinueWhenAny(taskList.ToArray(),m=>{
	Console.WriteLine("")
})

2.ContinueWhenAll

Task.Factory.ContinueWhenAll(taskList.ToArray(),m=>{
	Console.WriteLine("")
})

异步编程Async/Await

async/await是C#5.0引入的一个关键词，其目的是让异步编程边的更加简洁，也是为了顺应异步编程的大趋势。

功能：

1使用async/await能简单的创建异步方法，异步方法可以防止耗时操作阻塞当前线程。

2使用async/await来构建异步方法，更加简洁。

语法

① 方法使用async作为修饰符

② 方法内部包含一个或者多个await表达式，表示可以异步完成的任务

③ 必须具备以下三种返回类型 void 、Task 、Task ,其中后两种的返回对象标识未来完成的工作，调用方法和异步方法可以继续执行。

④异步方法的参数可以任意类型，但是不能为out和ref参数

⑤约定俗成，一般异步方法都是以 Async作为后缀的。

⑥ 除了方法之外，Lambda表达式和匿名函数也可以作为异步对象。

异步方法的控制流

1首先第一个await之前的部分，这部分应该是少量且无需长时间等待的代码。

2await表达式，表示需要被异步执行的任务，await可以有多个。

3在await表达式之后出现的方法的其余代码。

例子1：

public static async Task DoSomethingAsync()
        {
            Console.WriteLine("异步方法同步部分1");
            long sum = 0;
            sum = await Task.Run(() =>
            {
                Console.WriteLine("异步执行部分1,线程ID：{0}",Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(2000);
                long result = 0;
                for (var i = 0; i < 1000000000; i++)
                {
                    result += i;
                }
                Console.WriteLine("异步执行部分结束");
                return result;
            });
            Console.WriteLine("计算结果{0}", sum);

        }

例子2：

 public static async void DoSomethingAsync()
        {
            Task t1 = new Task(()=> {

                Console.WriteLine("异步开始了,线程：{0}", Thread.CurrentThread.ManagedThreadId);
                long result = 0;
                for (int i = 0; i < 1000000000; i++)
                {
                    result += i;
                }
                Console.WriteLine("异步结束，计算结果{0},线程{1}", result, Thread.CurrentThread.ManagedThreadId);

            });
            t1.Start();
            await t1;
           

        }

async/await和普通异步的对比

思考：实现一个程序，每次任务休眠5秒后，返回100，打印100

 public static void DoSomething()
        {
            Console.WriteLine("异步方法开始1");
            var aaa= await Task.Run(() =>
            {
                Thread.Sleep(5000);
                return 100;
            });
            Console.WriteLine("计算结果{0}",  aaa.result);
        }

调用：

 static void Main(string[] args)
 {
    DoSomething();
    DoSomething();
    DoSomething();
 }

解释：上述代码运行后，是同步执行的，虽然Task会异步产生一个线程运行，但是由于Task中的返回值需要使用aaa.result获取，阻塞了线程，所以运行结果是同步的。

将上述代码改装为异步：

 public  static void DoSomething111()
        {
            Console.WriteLine("异步方法开始1");
            //通过第一个异步方法得到结果

           var aaa= Task.Run(() =>
            {
                Thread.Sleep(5000);
                return 100;
            });
            aaa.ContinueWith(x =>
            {
                Console.WriteLine(x.Result);
            });
        }

解释：由于Task.Run()返回的是一个Task对象，所以如果不希望阻塞线程，那么可以调用ContinueWith进行回调处理，在回调中获取Task的返回值，ContinueWith不会阻塞主线程。

优雅的写法async/await

 public async  static void DoSomething111()
        {
            Console.WriteLine("异步方法开始1");
            //通过第一个异步方法得到结果

           var aaa= await Task.Run(() =>
            {
                Thread.Sleep(5000);
                return 100;
            });

            Console.WriteLine("结果是{0}", aaa);
        }

解释：Task.Run()执行的是一个耗时任务，await标记表示等待任务结果，将结果赋值给aaa，没错，就是这么优雅。

Socket

概念

socket的英文原义是“孔”或“插座”。作为进程通信机制，取后一种意思。通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄（其实就是两个程序通信用的）。
socket非常类似于电话插座。以一个电话网为例：电话的通话双方相当于相互通信的2个程序，电话号码就是ip地址。任何用户在通话之前，首先要占有一部电话机，相当于申请一个socket；同时要知道对方的号码，相当于对方有一个固定的socket。然后向对方拨号呼叫，相当于发出连接请求。对方假如在场并空闲，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭socket，撤销连接。

Socket使用步骤

img

服务器端：

第一步：创建一个用于监听连接的Socket对像；

第二步：用指定的端口号和服务器的ip建立一个EndPoint对像；

第三步：用socket对像的Bind()方法绑定EndPoint；

第四步：用socket对像的Listen()方法开始监听；

第五步：接收到客户端的连接，用socket对像的Accept()方法创建一个新的用于和客户端进行通信的socket对像;

第六步：通信结束后一定记得关闭socket;

客户端：

第一步：建立一个Socket对像；

第二步：用指定的端口号和服务器的ip建立一个EndPoint对像；

第三步：用socket对像的Connect()方法以上面建立的EndPoint对像做为参数，向服务器发出连接请求；

第四步：如果连接成功，就用socket对像的Send()方法向服务器发送信息；

第五步：用socket对像的Receive()方法接受服务器发来的信息 ;

第六步：通信结束后一定记得关闭socket；

↑中
关注
专栏目录
.NET/C# 多线程和异步-Task和async/await使用
Code365
07-10 1179
通过上边的介绍，我们知道async/await是基于Task的，而Task是对ThreadPool的封装改进，主要是为了更有效的控制线程池中的线程(ThreadPool中的线程，我们很难通过代码控制其执行顺序，任务延续和取消等等)；task.WhenAll(Task[] tasks) 表示所有的task都执行完毕后再去执行后续的操作， task.WhenAny(Task[] tasks) 表示任一task执行完毕后就开始执行后续操作。上边的所有示例中Task的执行都是异步的，不会阻塞主线程。
关于.net core中异步线程Task.Factory.StartNew导致上下文失效的问题
人生在手
12-07 883
1、Task.Factory.StartNew 与上下文的问题
C#异步Task
qq_39446394的博客
07-01 180
笔记整理(原资源网址): https://www.bilibili.com/video/BV1Zf4y117fs?p=12 Task Thread 的问题 线程（Thread）是用来创建并发（concurrent）的一种低级别工具，它有一些限制，尤其是： 虽然开始线程的时候可以方便的传入数据，但是当 Join 的时候，很难从线程获得返回值。 可能需要设置一些共享字段。 如果操作抛出异常，捕获和传播该异常都很麻烦。 无法告诉线程在结束时开始做另外的工作，你必须进行 Join 操作（在进程中阻塞当前的
java stream 转map_JDK源码阅读-Stream的创建与执行
weixin_32006353的博客
12-26 464
JDK源码阅读-Stream的创建与执行写在前面本文主要涉及java.util.stream包的代码，所使用JDK源码版本为jdk-11.0.3.一个简单的Stream例子：import java.util.stream.Stream; public class Test { public static void main(String[] args) { Stream...
Java使用线程实现异步运行
最新发布
m0_72958694的博客
07-05 1903
本文详细介绍了Java使用线程实现异步运行的三种方法，给出了三个详细的代码示例；同时介绍了在Java中实现异步运行的方法，干货满满。
Task异步任务
zfz6666的博客
08-30 912
Task 多线程编程的复杂性体现点·： （1）监控异步操作的状态不要使用轮询或者阻塞等待的方式 （2）线程池 （3）避免死锁 （4）为不同的操作提供原子性并同步数据访问 从Thread到Task：
异步线程
weixin_45958605的博客
12-02 1035
1、启动类需要加上@EnableAsync注解，开启异步 @SpringBootApplication @EnableAutoConfiguration(exclude = {MultipartAutoConfiguration.class}) @ComponentScan(basePackages = "com.asia") @MapperScan("com.asia.dao") @Enab...
Task异步操作
weiwei_y的博客
06-14 269
task创建、开启、阻塞、延续、取消
c#Winform异步线程刷新UI
12-27
本文将详细探讨如何在WinForm应用中使用异步线程来刷新UI，并实时反馈任务进度。 首先，让我们了解什么是异步编程。异步编程允许我们在不阻塞主线程的情况下执行长时间运行的任务。在UI应用程序中，主线程负责处理...
Unity异步线程调用主线程脚本
11-05
Unity异步线程调用主线程脚本程序，在Unity中异步线程调用主线程会报错，所以编写了一个Loom
C#用委托BeginInvoke做异步线程
12-31
需要耗费相当长的时间，这样，如果是一个线程同步式的做下去，那么用户在浏览器上感觉就是卡住了，卡卡卡卡，这里我们利用委托的BeginInvoke和EndInvoke方法操作线程，BeginInvoke方法可以使用线程异步地执行委托所...
线程异步方法
ad50863306的博客
04-26 138
1.beginInvoke，EndInvoke 不会阻塞调用它的线程，异步是相对调用它的线程来说的。 2.Polling（轮询） IAsyncResult中IsCompleted属性， 阻塞主线程，没有什么实际作用，浪费系统资源。 3. Wait Handle响应，使用IAsyncResult中的AsyncWaitHandle属性去调用handle的waitone函数，阻塞主线程，使...
异步task处理
afeyfre41671的博客
03-06 98
public async Task<Customers> GetCustomers() { return await Service.GetCustomersAsync(); } public async void GetCustomers() { customerList = await GetCustomers(); } 引...
线程异步详细介绍
qwert
03-22 2847
线程和异步是计算机科学中比较重要的概念，下面我将详细介绍线程和异步的含义、区别和应用。
Task异步多线程
weixin_43482965的博客
01-02 374
Thread类：表示托管线程，每个Thread对象都代表这一个托管线程，每个托管线程都对应这一个函数。 用Thread异步执行不同任务 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading; using Sy
异步多线程（Task）
佛陀爱老虎的博客
06-05 1202
Task Task 1.利用Task开启异步多线程： 2.回调： 3.等待： 4.获取返回结果： 使用的是线程池的线程，全部都是后台线程。不要在Task里面去启动Task。 1.利用Task开启异步多线程： （1）Task.Run var task = Task.Run(()=&amp;gt; this.DoSomethingLon...
异步线程的使用
dbzn13732的博客
07-10 148
同步与异步的好处坏处 1）.同步方法卡界面，因为UI线程忙于计算；异步多线程方法不卡界面，主线程闲置，计算任务交个子线程去做； 2）.同步方法慢，只有一个线程计算；异步多线程方法快，多线程并发计算（多线程的资源消耗更多，线程并不是越多越好）； 3）.异步多线程是无序的：启动无序，执行时间不确定，结束无序，所以我们不要试图通过启动顺序或是时间等待来控制流程。 public cl...
spiringboot 异步线程
08-31
异步线程的工作机制是通过任务调度器（Task Executor）来管理线程池和任务队列。当异步方法被调用时，Spring Boot 会将该方法封装为一个任务，并放入任务队列中。任务调度器会从任务队列中取出任务，并利用线程池中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值