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

最新推荐文章于 2024-09-26 16:54:06 发布
最新推荐文章于 2024-09-26 16:54:06 发布
阅读量1.8k 收藏 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)
在这里插入图片描述

总结

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

Toby.Dawson
关注
.netcore-线程池饿死问题分析（CPU空闲，并发量大时请求超时）
网尘的技术专栏
01-17 6453
如果您是使用.net或.net core平台编写服务时服务负载能力已经达到顶峰，而CPU并没有得到充分利用，看看这篇文章，那么或许你可以得到一些启发。 目录1、问题现象2、线程数不够3、什么是线程池4、什么是异步编程？5、通常是什么导致阻塞？6、我怎么知道ThreadPool缺少线程？6.1、PerfView / threadTime收集6.2、寻找增长的线程数。6.3、查找阻塞API6.4、...
.NET/C# 多线程和异步-Task和async/await使用
Code365
07-10 1269
通过上边的介绍，我们知道async/await是基于Task的，而Task是对ThreadPool的封装改进，主要是为了更有效的控制线程池中的线程(ThreadPool中的线程，我们很难通过代码控制其执行顺序，任务延续和取消等等)；task.WhenAll(Task[] tasks) 表示所有的task都执行完毕后再去执行后续的操作， task.WhenAny(Task[] tasks) 表示任一task执行完毕后就开始执行后续操作。上边的所有示例中Task的执行都是异步的，不会阻塞主线程。
C#多线程和异步（二）——Task和async/await详解
banyongzhan5405的博客
06-12 1355
一、什么是异步 　　同步和异步主要用于修饰方法。当一个方法被调用时，调用者需要等待该方法执行完毕并返回才能继续执行，我们称这个方法是同步方法；当一个方法被调用时立即返回，并获取一个线程执行该方法内部的业务，调用者不用等待该方法执行完毕，我们称这个方法为异步方法。 　　异步的好处在于非阻塞(调用线程不会暂停执行去等待子线程完成)，因此我们把一些不需要立即使用结果、较耗时的任务设为异步执...
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 就是这样-您现在可以开始运行！
C#.NET多线程编程与实例教程
最新发布
weixin_35706067的博客
09-26 1011
本文还有配套的精品资源，点击获取 简介：C#在.NET框架中提供了丰富的多线程支持，本教程将详细介绍如何创建和管理线程，包括线程的基本使用、线程同步与互斥，以及线程安全的数据访问和异步编程模式。具体实现方法包括使用 Thread 类、 Monitor 、 Mutex 、 Semaphore 等关键字和类，以及 ...
【.NET Core】 多线程之（Thread）详解
记录总结工作过往
01-18 1925
线程被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及复杂且耗时的操作，那么设置不同的线程执行路径往往事半功倍，让每个线程执行特定的工作任务。线程是一个轻量级进程。一个使用线程的常见实例是操作系统中并行编程的实现。使用线程节省了CPU周期的浪费，同时提高了应用程序的效率。本文将讲详细讲解Thread线程的用法。Thread类位于命名空间下，命名空间提供一些可以进行多线程编程的类和接口。除同步线程活动和访问数据的类（MutexMonitor和等）外，该命名空间还包含一个。
.NETCore 多线程学习笔记(多线程、线程结束顺序掌控、线程相对平均分配)
qq_39788123的博客
01-12 1643
.NETCore 多线程学习笔记(多线程、线程结束顺序掌控、线程相对平均分配)
.net core底层入门学习笔记（七-多线程）
kylinok的博客
07-15 1285
.net core底层入门学习笔记（七） 本篇开始记录.net中多线程的实现原理 文章目录.net core底层入门学习笔记（七）前言一、原生线程一、上下文切换二、线程调度三、栈空间二、托管线程一、托管线程对象二、前台线程与后台线程二、使用步骤1.引入库2.读入数据总结 前言 多线程机制，解决如何在有限的CPU核心上执行多个任务的一种机制。 由操作系统管理的现成为原生线程，.net基于原生线程搭建了一套线程模型，托管代码在这套线程模型上运行，称为托管线程。 一、原生线程 主流操作系统通过多线程机制
多线程实现方法 (threadpool and async method) in .Net Core.
Free Labor 的专栏
05-13 330
.NET CORE 中实现多线程的两种方法(个人经验总结)，两种方法使用的场景不同 1.使用ThreadPool using System; using System.Collections.Generic; using System.Text; using System.Threading; using System.Threading.Tasks; namespace ConsoleApp1 { public class MyThreadPool { public
.NETCore——依赖注入
weixin_45756851的博客
08-08 3158
Transient(瞬态)；Scoped(范围)；Singleton(单例)
.net core 面试题 2023
wf824284257的博客
04-06 3165
值类型包括C#的基本类型（用关键字int、char、float等来声明），结构（用struct关键字声明的类型），枚举（用enum关键字声明的类型），可空类型（int?依赖注入将对象的生命周期交给DI框架来管理，在使用这些对象的时候，不需要new出来，而是直接从container中获取，从而降低了耦合性，降低了依赖，值类型的实例通常是在线程栈上分配的（静态分配），但是在某些情形下可以存储在堆中。1. Singleton 单例的，注册时创建，永久存在，相当于静态类，适合使用频繁，工具类类型的service。
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例)
03-22
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例)
C#.NET多线程实例6个,可直接运行.rar
06-18
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例),可直接运行，希望能帮到初学者
.NET CORE 分布式事务(三) DTM实现Saga及高并发下的解决方案
m0_59178355的博客
03-26 2212
可以这么思考，如果发货的操作返回了失败，那么这个失败的含义是不够清晰的，调用方不知道这个失败是修改了部分数据的失败，还是修改数据前的业务校验失败，因为这个操作不可回滚，所以调用方收到这个失败，是不知道如何正确处理这个错误的。例如dtm的补偿操作，是要求最终成功的，只要还没成功，就会不断进行重试，直到成功。另外当你的一个全局事务中，如果出现了两个既不可回滚的又可能返回失败的操作，那么到了实际运行中，一个执行成功，一个执行失败，此时执行成功的那个事务无法回滚，那么这个事务的一致性就不可能保证了。
【.NET 6】多线程的几种打开方式和代码演示
WeskyNet
06-19 1408
前言： 多线程无处不在，平常的开发过程中，应该算是最常用的基础技术之一了。以下通过Thread、ThreadPool、再到Task、Parallel、线程锁、线程取消等方面，一步步进行演示多线程的一些基础操作。欢迎大家围观。如果大佬们有其他关于多线程的拓展，也欢迎在评论区进行留言，大佬们的知识互助，是.net生态发展的重要一环，欢迎大佬们进行留言，帮助更多的人。 本文章为了防爬虫，特此放上原文链...
.net core多线程：Thread
Cool2Feel的博客
08-11 5154
学习多线程的第一步，就是学习 Thread。Thread 类可以创建和控制线程，设置其优先级并获取其状态。这一篇将开始学习线程的创建和生命周期。 官方文档 Thread 类详细的属性和方法： https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.thread?view=netcore-3.1#properties 1，获取当前线程信息 Thread.CurrentThread 是一个 静态的 Thread 类，Thread 的Curre.
NetCore多线程认识进阶
u010565069的博客
01-24 1446
前言 进程：程序在服务器上运行时，占据的计算机资源集合，称之为进程。进程之间是不会相互干扰，也就是说进程间不能直接通讯，需要通过一定的设计模式，如分布式服务 线程：程序执行的最小单位，影响操作的最小执行单位。线程属于进程，所以线程也有自己的资源，一个进程有多个线程。 多线程：一个进程里，有多个线程并发执行。.NET封装一个抽象线程类Thread，通过Thread去完成各种操作，Thread最终又是通过向操作系统请求得到的执行流 正文 1、多线程的表现 多线程是用资源换性能 1个线程13000秒 5个线
NetCore 多线程的写法
qq_38826774的博客
06-06 155
【代码】NetCore 多线程的写法。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值