【.net6第四章】.NetCore多线程

于 2024-02-26 00:46:57 发布
阅读量1.1k 收藏 22
点赞数 23
文章标签： .net .netcore 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CZ_TyT/article/details/135944784
版权

文章目录

提示：以下是本篇文章正文内容，下面案例可供参考

一、进程、线程、句柄，同步、异步

进程：就是计算机概念，一种虚拟的记录，描述一个应用在计算机上运行的时候，所消耗的各种资源你的集合。例如：CPU，磁盘，网络资源。
线程：某一个程序进程中所执行的具体的某一个动作的最小执行流。
句柄：句柄是对系统资源的抽象引用，程序员通常不需要知道具体的内存地址或资源的物理布局，只需通过句柄来操作这些资源。
同步：主要涉及多个进程、线程或操作的协调，以确保它们以一种有序和一致的方式运行。
异步（Asynchronous）：编程是一种编程范式，它允许某些任务在后台运行，而不会阻塞（即停止执行）主程序流程。在异步操作中，程序可以在等待异步任务完成的同时继续执行其他任务，这对于提高应用程序的响应性和性能尤其重要

二、Task

Task和prallel的所操作的线程都是来自线程池。

1.线程开启

开启线程方式：

Task task = new Task(new Action(() =>
{
      Console.WriteLine("Hello World!");
}));
task.Start(); //开启线程

Task.Run(() =>
{
      Console.WriteLine("Hello World!");
});

Task.Run<int>(() =>
{
    return DateTime.Now.Year;
});

TaskFactory factory = Task.Factory;
factory.StartNew(() =>
{
        Console.WriteLine("Hello World!");
});

TaskFactory factory = new TaskFactory();
Task<int> tTask = factory.StartNew<int>(() => DateTime.Now.Year);

父子级线程：
一个Task内部，开启了几个线程以后；Task内部的线程可以理解为子线程；
父线程在等待的时候，子线程没有线程等待；子线程可能内容还没有执行万一，父线程就已经结束了；

Task task = new Task(() =>
{
    Debug.WriteLine($"task开始了: {Thread.CurrentThread.ManagedThreadId.ToString("00")} ");
    Task task1 = new Task(() =>
    {
        Debug.WriteLine($"task1: {Thread.CurrentThread.ManagedThreadId.ToString("00")} ");
        Thread.Sleep(1000);
        Debug.WriteLine("我是task1线程");
    });

    Task task2 = new Task(() =>
    {
        Debug.WriteLine($"task2: {Thread.CurrentThread.ManagedThreadId.ToString("00")}");
        Thread.Sleep(1000);
        Debug.WriteLine("我是task2线程");
    });
    task1.Start();
    task2.Start();
    Debug.WriteLine($"task: {Thread.CurrentThread.ManagedThreadId.ToString("00")}");
});
task.Start();//线程启动了
task.Wait();   //单个线程的等待；等待task 内部的内容执行完毕，这里会卡顿界面；是主线程等待；


//TaskCreationOptions.PreferFairness 相对来说比较公平执行的：如果是先申请的线程，就会优先执行；
 Task task1= new Task(() =>
{

}, TaskCreationOptions.PreferFairness);

Task task2 = new Task(() =>
{

}, TaskCreationOptions.PreferFairness);

在这里插入图片描述

2.线程等待

Task task = Task.Run(() =>
{
    Debug.WriteLine("Hello World");
});
task.Wait(); //等待这个线程执行完毕

Thread.Sleep(100); //主线程执行到这里会卡顿等待，100ms后继续执行

Task.Delay(300); //不卡顿界面延迟300ms继续执行逻辑

//不卡顿界面：言辞3000ms以后，去执行一段业务逻辑：执行的动作就是ContinueWith内部的委托；
//ContinueWith内部的执行有可能是一个全新的线程去执行，也有可能是主线程去执行； 
Task.Delay(3000).ContinueWith(t =>
{
    Debug.WriteLine($"Delay || 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
    stopwatch.Stop();
    Debug.WriteLine($"Task.Delay(3000):{stopwatch.ElapsedMilliseconds}");
});

3.线程等待的多种方式

场景模拟：现在需要多人同时开发一个项目，那么我们就可以开启多线程去完成。

List<Task> taskList = new List<Task>();
TaskFactory factory = new TaskFactory();

taskList.Add(factory.StartNew(() =>Coding("A","负责权限的数据库设计")));
taskList.Add(factory.StartNew(() => Coding("B","负责WeChat接口对接")));
taskList.Add(factory.StartNew(() => Coding("C","负责脚手架框架搭建")));
taskList.Add(factory.StartNew(() => Coding("D","负责ABPVNetxt框架搭建")));
taskList.Add(factory.StartNew(() => Coding("E","负责编写Webapi")));

正常情况下我们我们不需要去考虑完成的前后顺序，那么我要在上面任何以为的工作完成之后，F来搭建环境要如何处理呢？

//方案一：
//Task.WaitAny：等待几个线程中的某一个线程执行结束，主线程会等待，会卡顿界面，一直到某一个线程执行结束后，才往后执行。体验不好 ！！！
Task.WaitAny(taskList.ToArray());
Debug.WriteLine($"F准备环境");

//方案二：
//相当于是一个回调；主线程执行的时候，不会阻塞UI界面；当taskList集合中的某一个线程执行结束语了；就触发后面委托中的动作；
factory.ContinueWhenAny(taskList.ToArray(), ts =>
{
    Debug.WriteLine($"F准备环境");
});

如果所有人开发完毕后，要正式上线要如何处理呢？

//方案一：
//主线程等待，阻塞UI界面，其中某一个线程执行结束，然后继续往后执行；
Task.WaitAny(taskList.ToArray());
Task.WaitAll(taskList.ToArray());
Debug.WriteLine($"正式上线！！！");

//方案二：
factory.ContinueWhenAll(taskList.ToArray(), ts =>
{
    Debug.WriteLine($"正式上线！！！");
});

演变=》如果要知道那个最先开发完成，我们也可以通过状态来判断。

List<Task> taskList = new List<Task>();
TaskFactory factory = new TaskFactory();

taskList.Add(factory.StartNew(obj => Coding("A","负责权限的数据库设计"),"A"));
taskList.Add(factory.StartNew(obj => Coding("B","负责WeChat接口对接"), "B"));
taskList.Add(factory.StartNew(obj => Coding("C","负责脚手架框架搭建"), "C"));
taskList.Add(factory.StartNew(obj => Coding("D","负责ABPVNetxt框架搭建"), "D"));
taskList.Add(factory.StartNew(obj => Coding("E","负责编写Webapi"), "E"));

factory.ContinueWhenAny(taskList.ToArray(), ts =>
{
    Debug.WriteLine($"{ts.AsyncState}开发完成,,F准备环境");
});

factory.ContinueWhenAll(taskList.ToArray(), ts =>
{
    Debug.WriteLine($"正式上线");
});

Console.Read();

 void Coding(string name, string projectName)
{
    Debug.WriteLine($"Coding Start  || {name} {projectName}  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}");
    long lResult = 0;
    for (int i = 0; i < 1_000_000_000; i++)
    {
        lResult += i;
    }
    Thread.Sleep(3000);
    Debug.WriteLine($"Coding   End ||  {name} {projectName} {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} {lResult}");
}

运行结果：
在这里插入图片描述

4.线程等待应用场景

ContinueWhenAny：如果需要在一堆任务中，某一种执行结束后，去触发一个动作；
ContinueWhenAll：如果需要回调和需要控制顺序
WaitAny：如果有不确定的数据源，比如可能是缓存，可能是数据库，可能是第三方接口的时候，我们可以使用WaitAny，只要查到任何一种数据源的数据就直接返回
WaitAll：例如有多个模块信息需要同时加载时。
我之前在做首页优化接口时，也是使用多线程加载各个模块数据：

await Task.WhenAll(
    Task.Run(async () =>
    {
        //首页模块A
    }),
    Task.Run(async () =>
    {
        //首页模块B
    }),
    Task.Run(async () =>
    {
        //首页模块C
    })
);

三、Parallel

1.可以传入多个委托
2.多个委托中的内容是会开启线程来执行—执行这里的线程有可能是新的线程，也有可能是主线程参与计算的
3.会阻塞主线程—相当于是主线程等待子线程执行结束

List<Action> acitonList = new List<Action>();
acitonList.Add(() => { });
acitonList.Add(() => { });
acitonList.Add(() => { });
Parallel.Invoke(acitonList.ToArray());//也是可以开启线程，可以一次放入很多个委托去执行；

我们可以看下这个的运行结果：

Task.Run(() =>
{ 
    Parallel.Invoke(
  () =>
  {
      Debug.WriteLine($"线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")}");
      this.DoSomething("this is Action 01");
  },
  () =>
  {
      Debug.WriteLine($"线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")}");
      this.DoSomething("this is Action 02");
  },
  () =>
  {
      Debug.WriteLine($"线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")}");
      this.DoSomething("this is Action 03");
  });
});

在这里插入图片描述
如果想要不阻塞主线程，可以在外围包一个Task.Run。Parallel是基于Task一个封装；
那么Parallel有什么作用呢？
如果有一大堆的任务要执行；100个任务—需要多线来执行：100个任务要开启100个线程？

Parallel.For(0,100,index=>
 {
    //执行任务
 })

那么我们Parallel最大的优势就是可以控制线程的数量，不至于出现线程泛滥的情况

ParallelOptions options = new ParallelOptions();
//开启5个线程去去执行100个任务
 options.MaxDegreeOfParallelism =5
 Parallel.ForEach(intlist, options, s =>
{
    //执行任务
});

四、多线程的异步处理

我们在日常代码中常常使用try…catch…finally…去捕捉到异常，那么我们在多线程中要如何处理呢？
1.在多线程中，如果发生异常，使用try-catch包裹，是捕捉不到异常的，异常肯定是被吞掉了
2.多线程中，如果要捕捉异常，需要设置主线程等待子线程执行结束；可以捕捉到异常
在这里插入图片描述
3.多线程内部发生异常后，抛出的异常类型是：system.AggregateException(多线程的异常类型)
在这里插入图片描述
当多个线程发生异常要如何捕捉到呢？我们可以做个demo进行测试

try
{
    List<Task> tasklist = new List<Task>();
    for (int i = 0; i < 20; i++)
    {
        string keywork = $"Click_{i}";
        tasklist.Add(Task.Run(() =>
       {
           Thread.Sleep(new Random().Next(50, 100));
           if (keywork == "Click_6")
           {
               throw new Exception("Click_6");
           }
           else if (keywork == "Click_9")
           {
               throw new Exception("Click_9");
           }
           else if (keywork == "Click_12")
           {
               throw new Exception("Click_12");
           }
       }));
    }
    Task.WaitAll(tasklist.ToArray());

}
catch (AggregateException aex) //具体
{
    Debug.WriteLine(aex.Message);
    foreach (var exception in aex.InnerExceptions)
    {
        Console.WriteLine(exception.Message);
    }
}
catch (Exception ex) //父类（Exception 一切异常的父类） 抽象
{
    Debug.WriteLine(ex.Message);
}

我们可以看到AggregateException 会有异常集合！！！

那么我们模拟一个场景，如果三个线程去执行一个业务逻辑体（查询：线程1，执行修改数据库；线程2，执行修改缓存，线程3，执行一个调用接口去修改另外一个服务器上的数据），如果中间有某一个线程出现异常了，那就代表整个逻辑有问题，那要如何处理？
多线程执行的时候，有时候，必须是多个线程都执行成功，才算成功，只要有一个线程异常了，就表示都异常----既然都是异常了，就应该让线程取消，逻辑取消

五、线程取消

线程取消：线程是无法从外部取消的（除非关闭进程），只能自己取消自己。
如何执行标准的线程取消？
1.实例化一个 CancellationTokenSource
2.包含了一个IsCancellationRequested 属性，属性值默认为false
3.包含了一个Cancel方法。Cancel的作用：方法如果被执行，CancellationTokenSource内部的属性值由false变为true，且只能从false变为true

demo：


try
{
    List<Task> tasks = new List<Task>();
    CancellationTokenSource cts = new CancellationTokenSource();
    for (int i = 0; i < 100; i++)  //开启并发线程
    {
        string keywork = $"task_{i}";
        Task.Run(() =>
        {
            Thread.Sleep(new Random().Next(10, 300)); //随机休眠
            if (cts.IsCancellationRequested == false)
            {
                Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 正常开始了");
            }
            else
            {
                Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 没有正常开始了");
            }

            try
            {
                
                if (keywork  == "task_9")
                {
                    throw new Exception("task_9");
                }
                if (keywork == "task_6")
                {
                    throw new Exception("task_6");
                }
            }
            catch (Exception)
            {
                cts.Cancel();  //取消线程
            }

            if (cts.IsCancellationRequested == false)
            {
                Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 正常结束了。。。");
            }
            else
            {

                Debug.WriteLine($" 线程ID:  {Thread.CurrentThread.ManagedThreadId.ToString("00")} {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")} 没有正常结束了。。。");

            }
        });
    }
}
catch (AggregateException aex)
{
    foreach (var exception in aex.InnerExceptions)
    {
        Debug.WriteLine(exception.Message);
    }
}

你们可以自己拿这个demo执行看结果。。。。

4…当有一个线程发生异常的时候，其他线程就会有三种情况：1.已经结束的线程无法去处理，2.已经正常开始，我可以让你取消，让这线程在结束的时候，抛出异常（取消了）；3.还有部分的线程根本都还没有开启：只要有异常的线程，就应该让没有开启的线程不再开启了。


try
{
    List<Task> tasks = new List<Task>();
    CancellationTokenSource cts = new CancellationTokenSource();
    for (int i = 0; i < 100; i++)
    {
        string keywork = $"Task_{i}";
        tasks.Add(Task.Run(() =>
        {
            Thread.Sleep(new Random().Next(10, 300));
            cts.Token.ThrowIfCancellationRequested();

            try
            {
                //为什么要先定义一个字符串，然后在这里判断？ 
                if ($"Task_{i}" == "Task_9")
                {
                    throw new Exception("Task_9");
                }
                if (keywork == "Task_6")
                {
                    throw new Exception("Task_6");
                }
            }
            catch (Exception)
            {
                cts.Cancel();
            }
            cts.Token.ThrowIfCancellationRequested();
        }, cts.Token)); //有线程发生异常后，还没有开启的线程就不再开启了
    }
    Task.WaitAll(tasks.ToArray());
}
catch (AggregateException aex)
{
    foreach (var exception in aex.InnerExceptions)
    {
        Debug.WriteLine(exception.Message);
    }
}

输出：
在这里插入图片描述
这是表示有剩余未开启的线程已经取消

六、 线程安全

线程安全：一段完整的业务逻辑，单线程执行和多线程执行后的结果如果完全一致，是线程安全的；否则就表示是线程不安全；
这个就是最直接的线程安全问题：
在这里插入图片描述
因为我们开启的是多线程，其中就可能在同一个时刻出现抢占资源的情况，所以会出现线程安全问题。
那要如何解决线程安全问题呢？
1.加锁，标准锁，锁的本质是独占引用。可以解决线程安全问题，加锁是反多线程，会影响性能。

private readonly static object obj = new object();

在这里插入图片描述

2.使用单线程，把要操作的整块数据做一个切分。例如9w条数据，分成三块，再开启多线程，每个线程去执行3W条数据，等待三个线程执行结束后，在单线程做一个汇总。（这个需要将程序加以设计）

3.使用线程安全对象。
这是系统提供的三种线程安全数据集

BlockingCollection<int> blockinglist = new BlockingCollection<int>();
ConcurrentBag<int> conocurrentbag = new ConcurrentBag<int>();
ConcurrentDictionary<string, int> concurrentDictionary = new ConcurrentDictionary<string, int>();
ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();
ConcurrentStack<int> concurrentStack = new ConcurrentStack<int>();

七、中间变量

在这里插入图片描述
为什么我们每次循环开启多线程，i一直是等于5的呢？
因为Task开启线程的时候是延迟开启的，延迟的时间很短。循环并不会阻塞主线程，当有一个线程在正式的执行业务逻辑的时候，循环已经结束了，所以会取到最后的值！！！

如何解决？
可以另外定义个变量，在每次循环的时候赋值，循环多少次就会有多少个变量(k)，每个线程使用的是每一次循环内部的变量(k)
在这里插入图片描述

总结

如果还有其他思路请在评论区指出，我们继续完善，，往共勉！！！！！！！

.net_小周
关注
  • 23
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
core-dotnet:.NET Core的多线程批处理和后台作业
04-23
.NET Core的多线程批处理和后台作业 Runly是一个框架，可通过编写分隔的，可测试的代码来简化复杂的应用程序。 您专注于编写业务逻辑，Runly为您提供CLI，多线程，重试以及更多现成的功能。 它是如何工作的？ 您将作业构建为从Job继承到新控制台应用程序中的类。 您引用，您将立即拥有一个功能全面且功能强大的CLI应用程序。 :rocket: 开始使用 有两种方法引导Runly作业应用程序： 从创建一个新的Job应用程序。 这将为您创建一个新的存储库，您可以克隆该存储库并立即开始运行。 跳过Git存储库，并通过dotnet new模板创建本地应用程序： 首先，安装模板： dotnet new -i Runly.Templates 然后创建一个新项目： mkdir myproject cd myproject dotnet new runly-app 就是这样-您现在可以开始运行！
FastReport.net v2022.3.9 完美补丁，支持.Net6的版本
10-21
fastReport.net v2022.3.9 ,完美支持.Net6的版本。完美补丁，是从一个伊朗的网站下载的。目前还没有验证过补丁的完整情况。希望后来的使用者能在使用后报告一下使用体验
【.NET 6】多线程的几种打开方式和代码演示
WeskyNet
06-19 1301
前言： 多线程无处不在，平常的开发过程中，应该算是最常用的基础技术之一了。以下通过Thread、ThreadPool、再到Task、Parallel、线程锁、线程取消等方面，一步步进行演示多线程的一些基础操作。欢迎大家围观。如果大佬们有其他关于多线程的拓展，也欢迎在评论区进行留言，大佬们的知识互助，是.net生态发展的重要一环，欢迎大佬们进行留言，帮助更多的人。 本文章为了防爬虫，特此放上原文链...
.net研究院之多线程技术6-异常处理-线程间通知-临时变量-线程安全&Lock
qq_33931256的博客
09-27 242
多线程的异常处理示例 线程异常后经常是需要通知别的线程，而不是等到WaitAll，问题就是要线程取消 工作中常规建议：多线程的委托里面不允许异常，包一层try-catch,然后记录下来异常信息，完成需要的操作 如果某一个线程异常了，需要通知或终止其他线程示例 //多线程并发任务，某个失败后，希望通知别的线程，都停下来，how？ //Thread.Abort--终止线程；向当前线程抛一...
ASP.NET Core 多线程 异步编程
bianjing_2005的博客
12-22 2303
@ASP.NET Core 多线程 异步编程 同步异步编程 同步编程是对于单线程来说的，就像我们编写的控制台程序，以main方法为入口，顺序执行我们编写的代码。 异步编程是对于多线程来说的，通过创建不同线程来实现多个任务的并行执行。 线程 .Net 1.0就发布了System.Threading，其中提供了许多类型（比如Thread、ThreadStart等）可以显示的创建线程。 主线程 每一个W...
.NET Core多线程通关 (1) Thread与Task
dotNET跨平台
02-16 1402
【.NET Core】|总结/Edison Zhou大家好，我是Edison。去年换工作时系统复习了一下.NET Core多线程相关专题，学习了一线码农老哥的《.NET 5多线程编程实战》课程，我将复习的知识进行了总结形成本专题。同时也特别推荐有兴趣的读者去学习一线码农老哥的《.NET 5多线程编程》课程。本篇，我们来复习一下Thread与Task的相关知识点，预计阅读时间15~20分钟。从时间...
.net core底层入门学习笔记（七-多线程）
kylinok的博客
07-15 1196
.net core底层入门学习笔记（七） 本篇开始记录.net中多线程的实现原理 文章目录.net core底层入门学习笔记（七）前言一、原生线程一、上下文切换二、线程调度三、栈空间二、托管线程一、托管线程对象二、前台线程与后台线程二、使用步骤1.引入库2.读入数据总结 前言 多线程机制，解决如何在有限的CPU核心上执行多个任务的一种机制。 由操作系统管理的现成为原生线程，.net基于原生线程搭建了一套线程模型，托管代码在这套线程模型上运行，称为托管线程。 一、原生线程 主流操作系统通过多线程机制
【.NET Core】 多线程之（Thread）详解
最新发布
记录总结工作过往
01-18 1521
线程被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及复杂且耗时的操作，那么设置不同的线程执行路径往往事半功倍，让每个线程执行特定的工作任务。线程是一个轻量级进程。一个使用线程的常见实例是操作系统中并行编程的实现。使用线程节省了CPU周期的浪费，同时提高了应用程序的效率。本文将讲详细讲解Thread线程的用法。Thread类位于命名空间下，命名空间提供一些可以进行多线程编程的类和接口。除同步线程活动和访问数据的类（MutexMonitor和等）外，该命名空间还包含一个。
.NETCore 多线程学习笔记(多线程、线程结束顺序掌控、线程相对平均分配)
qq_39788123的博客
01-12 1537
.NETCore 多线程学习笔记(多线程、线程结束顺序掌控、线程相对平均分配)
NetCore 多线程的写法
qq_38826774的博客
06-06 97
【代码】NetCore 多线程的写法。
.Net多线程计划任务
01-15
很容易上手的一个.Net多线程的定时任务功能,Demo很容易上手，完成了以天、周、月等的计划任务
【ASP.NET编程知识】运用.NetCore实例讲解RabbitMQ死信队列,延时队列.docx
05-21
【ASP.NET编程知识】运用.NetCore实例讲解RabbitMQ死信队列,延时队列.docx
ASP.Net Core 5.0官方文档.pdf
07-31
ASP.NET core 5.0文档PDF(含目录，共5453页)。摘要： ASP.NET Core 文档及新增内容 ASP.NET 比较 .NET Core 和 .NET ...使用 ASP.NET Core 的 EF 6 ASP.NET Core 模块 迁移5.0 ASP.NET 到 ASP.NET Core API 参考
.NET Core类库System.Reflection.DispatchProxy实现简易Aop的方法
10-17
主要给大家介绍了关于.NET Core类库System.Reflection.DispatchProxy实现简易Aop的相关资料，文中通过示例代码结束的非常详细，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧
.net c# .netcore 视频解码源程序 基于ffmpeg rtsp rtmp 摄像头实时解码，实时播放 控制 存储，转
04-06
.net c# .netcore 视频解码源程序 基于ffmpeg rtsp rtmp 摄像头实时解码，实时播放 控制 存储，转换 源码 海康 合普 大华等摄像头的实时转码 实时播放，格式转换 core 跨平台
asp.Net Core 多线程之Task轻松学，快速上手
曾小芳的杂货铺
08-13 1584
Asp.Net Core 轻松学-多线程之Task快速上手 目录 前言 1. Task 的使用方法 3. 处理 Task 中的异常 4. 同步上下文 5. Task 的运行方式 6. 有条件的 Task 结束语 示例代码下载 前言 Task是从 .NET Framework 4 开始引入的一项基于队列的异步任务（TAP）模式，从 .NET Framework 4.5 开始，任何使用 async/await 进行修饰的方法，都会被认为是一个异步方法；实际上，这些异步方法都是基于队列的线程任务，从你
.NET多线程小记(6)：线程同步
weixin_34037977的博客
11-22 61
同步块的机制： 在.NET被加载时初始化同步块数组 每一个被分配在堆上的对象都会包含两个额外的字段，其中一个存储类型指针，而另外一个就是同步块索引，初始时被赋值为-1. 当一个线程试图使用该对象进入同步时，会检查该对象的同步索引。如果索引为负数，则会在同步块数组中寻找或者新建一个同步块，并且把同步块的索引值写入该对象的同步索引中。如果该对象的同步索引不...
ASP.net 的工作线程与请求队列
蝈蝈俊.net
03-17 5507
ASP.net工作线程池 当 ASP.NET 接收针对页的请求时，它从线程池中提取一个线程并将请求分配给该线程。 一个普通的（或同步的）页在该请求期间保留线程，从而防止该线程用于处理其他请求。如果一个同步请求成为 I/O bound（例如，如果它调用一个远程 Web 服务或查询一个远程数据库，并等待调用返回），那么分配给该请求的线程在调用返回之前处于挂起状态。 这影响了可伸缩性，原因是线程池
Error: An assembly specified in the application dependencies manifest (bbjApi.deps.json) was not found: package: 'runtimepack.Microsoft.NETCore.App.Runtime.linux-x64', version: '5.0.17' path: 'System.Net.Http.Json.dll'
07-08
这个错误表明在应用程序的依赖清单中找不到指定的程序集。具体来说，它表示缺少名为 'runtimepack.Microsoft.NETCore.App.Runtime.linux-x64' 版本为 '5.0.17' 的包，并且缺少 'System.Net.Http.Json.dll' 文件。 解决这个问题的一种方法是确保正确安装了所需的运行时。您可以尝试更新或重新安装 .NET Core 运行时，以确保所需的程序集可用。另外，还可以检查应用程序的依赖清单文件（bbjApi.deps.json）中是否存在任何错误或丢失的引用。 请注意，这是一种可能的解决方案，具体步骤可能因您的环境和应用程序配置而有所不同。如果问题仍然存在，请提供更多详细信息，以便我能够更好地帮助您解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值