asynchron asynchron, Thread-Multithreading in .NET

1. Task Task Task

System.Threading.Tasks wurde in .NET4 eingeführt, und es gibt zu viele APIs für frühere Threads Die Steuerung ist unpraktisch und die ThreadPool-Steuerungsfunktion ist zu schwach. Beispielsweise ist es nicht bequem, Thread-Fortsetzungs-, Blockierungs-, Abbruch-, Timeout- und andere Funktionen auszuführen, sodass Task die Thread-Funktion abstrahiert und ThreadPool

1. Starten Sie die Aufgabe

Sie können die TaskFactory-Klasse oder den Konstruktor und die Start()-Methode der Task-Klasse verwenden Eingabeparameter mit einem Objekttyp, sodass Sie beliebige Daten an die Aufgabe übergeben können, und auch einen häufig verwendeten Task.Run verpassen.

TaskFactory taskFactory = new TaskFactory();
taskFactory.StartNew(() => 
{
    Console.WriteLine($"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
Task.Factory.StartNew(() =>
{
    Console.WriteLine($"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
Task task = new Task(() =>
{
    Console.WriteLine($"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
task.Start();

Nur ​​die Task-Klasseninstanzmethode erfordert Start(), um die Aufgabe zu starten Natürlich kann RunSynchronously() verwendet werden, um die Aufgabe synchron auszuführen. Der Hauptthread wartet also, um diese Aufgabe auszuführen

Task task = new Task(() =>
{
    Thread.Sleep(10000);
    Console.WriteLine($"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
task.RunSynchronously();

2. Fortsetzung blockieren

In Thread verwenden wir Join, um das Warten zu blockieren. Es ist nicht praktisch, mehrere Threads zu steuern. In Task verwenden wir die Instanzmethode Wait, um eine einzelne Aufgabe zu blockieren, oder die statischen Methoden WaitAll und WaitAny, um mehrere Aufgaben zu blockieren.

var task = new Task(() =>
{
    Thread.Sleep(5*1000);
    Console.WriteLine($"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
var task2 = new Task(() =>
{
    Thread.Sleep(10 * 1000);
    Console.WriteLine($"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
task.Start();
task2.Start();
//task.Wait();//单任务等待
//Task.WaitAny(task, task2);//任何一个任务完成就继续
Task.WaitAll(task, task2);//任务都完成才继续

Wenn Sie den Hauptthread nicht blockieren möchten, können Sie andere Aufgaben gleichzeitig ausführen Task oder mehrere Tasks werden abgeschlossen. Verwenden Sie die statischen Task-Methoden WhenAll und WhenAny. Sie geben eine Task zurück, die Sie jedoch nicht steuern können. Sie wird dann automatisch abgeschlossen Die ContinueWith-Methode einer Aufgabe, um eine Aufgabe sofort abzuschließen, nachdem sie abgeschlossen ist

Task.WhenAll(task, task2).ContinueWith((t) =>
{
    Console.WriteLine($"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
Task.Factory工厂中也存在类似ContinueWhenAll和ContinueWhenAny

3. Aufgabenhierarchie

Sie können nicht nur nach dem Ende eine weitere Aufgabe ausführen Eine Aufgabe, aber Sie können auch eine innerhalb einer Aufgabenaufgabe starten, die eine Eltern-Kind-Hierarchie startet.

var parentTask = new Task(()=> 
{
    Console.WriteLine($"parentId={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
    Thread.Sleep(5*1000);
    var childTask = new Task(() =>
    {
        Thread.Sleep(10 * 1000);
        Console.WriteLine($"childId={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}")
    });
    childTask.Start();
});
parentTask.Start();

Wenn die übergeordnete Aufgabe vor der untergeordneten Aufgabe endet, lautet der Status der übergeordneten Aufgabe WaitingForChildrenToComplete Wird die Aufgabe ebenfalls abgeschlossen, wird der Status der übergeordneten Aufgabe zu RanToCompletion. Geben Sie beim Erstellen einer Aufgabe natürlich die Aufzählungsparameter TaskCreationOptions an, die das optionale Verhalten der Aufgabenerstellung und -ausführung steuern können

4

Eine kurze Einführung in das Erstellen von Aufgaben. Der Aufzählungsparameter TaskCreationOptions. Beim Erstellen einer Aufgabe können wir den Aufzählungsparameter TaskCreationOptions bereitstellen, ein Flag, mit dem das optionale Verhalten der Aufgabenerstellung und -ausführung gesteuert wird

AttachedToParent: Gibt an, dass die Aufgabe an die Aufgabenhierarchie angehängt werden soll. Das bedeutet, dass die übergeordnete Aufgabe auf den Abschluss der untergeordneten Aufgabe warten muss, bevor sie weiter ausgeführt werden kann. Der Effekt ist der gleiche wie bei WaitAll. Wenn im obigen Beispiel TaskCreationOptions.AttachedToParent beim Erstellen einer Unteraufgabe angegeben wird, wartet die übergeordnete Aufgabe beim Warten auch auf das Ende der Unteraufgabe.

DenyChildAttach: Die Unteraufgabe darf nicht an die übergeordnete Aufgabe angehängt werden

LongRunning: Geben Sie eine lang laufende Aufgabe an. Wenn Sie im Voraus wissen, dass die Aufgabe lange dauern wird, empfiehlt es sich, dies festzulegen. Auf diese Weise erstellt der Taskplaner Thread-Threads, anstatt ThreadPool-Threads zu verwenden. Da Sie den ThreadPool-Thread für längere Zeit belegen und ihn nicht zurückgeben, kann es sein, dass bei Bedarf ein neuer Thread im Thread-Pool geöffnet wird, was zu Planungsdruck führt

PreferFairness: Ordnen Sie Aufgaben so fair wie möglich an, was bedeutet, dass dies der Fall ist Sie werden früher geplant. Aufgaben werden mit größerer Wahrscheinlichkeit früher ausgeführt, und Aufgaben, die später ausgeführt werden sollen, werden mit größerer Wahrscheinlichkeit später ausgeführt. Tatsächlich wird die Aufgabe in die globale Warteschlange des Thread-Pools gestellt und die Arbeitsthreads werden um sie konkurrieren. Standardmäßig befindet sie sich in der lokalen Warteschlange.

Ein weiterer Aufzählungsparameter ist der Aufzählungsparameter TaskContinuationOptions in der ContinueWith-Methode. Er verfügt nicht nur über mehrere Aufzählungswerte mit denselben Funktionen wie oben, sondern verfügt auch über Funktionen wie die Steuerung des Abbruchs und der Fortsetzung von Aufgaben

LazyCancellation: Verhindert im Falle eines Fortsetzungsabbruchs den Abschluss der Fortsetzung, bis die vorherige Aufgabe abgeschlossen ist. Was bedeutet es?

CancellationTokenSource source = new CancellationTokenSource();
source.Cancel();
var task1 = new Task(() => 
{
    Console.WriteLine($"task1 id={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
var task2 = task1.ContinueWith(t =>
{
    Console.WriteLine($"task2 id={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
},source.Token);
var task3 = task2.ContinueWith(t =>
{
    Console.WriteLine($"task3 id={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
});
task1.Start();

Im obigen Beispiel versuchen wir, task1->task2->task3 nacheinander auszuführen und dann die Ausführung von task2 über CancellationToken abzubrechen. Was wird das Ergebnis sein? Infolgedessen werden Task1 und Task3 parallel ausgeführt (Task3 wird ebenfalls ausgeführt, und zwar parallel zu Task1, was bedeutet, dass die ursprüngliche Kette zu zwei Ketten wird), und dann versuchen wir,

LazyCancellation，
var task2 = task1.ContinueWith(t =>
{
    Console.WriteLine($"task2 id={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
},source.Token,TaskContinuationOptions.LazyCancellation,TaskScheduler.Current);

so zu verwenden dass es in Task1 sein wird, nachdem die Ausführung abgeschlossen ist, Task2 wird die Quelle beurteilen. Wenn es Abbrechen ist, wird es nicht ausgeführt. Die nächste Ausführung von Task3 stellt die ursprüngliche Reihenfolge sicher.

ExecuteSynchronously: Gibt an dass die Fortsetzungsaufgabe beispielsweise synchron ausgeführt werden soll. Wenn dieser Parameter in Aufgabe2 angegeben ist, wird Aufgabe2 mit dem Thread ausgeführt, der Aufgabe1 ausführt. Dies verhindert einen Thread-Wechsel und ermöglicht einen gewissen Zugriff auf gemeinsam genutzte Ressourcen . Wenn nicht angegeben, ist es zufällig, aber der Thread von Aufgabe1 kann auch verwendet werden

NotOnRanToCompletion: Die Fortsetzungsaufgabe muss im Nicht-Abschlusszustand der vorherigen Aufgabe ausgeführt werden

OnlyOnRanToCompletion: Die Fortsetzungsaufgabe muss sich im Abschlussstatus der vorherigen Aufgabe befinden. Zur Ausführung

NotOnFaulted, OnlyOnCanceled, OnlyOnFaulted usw.

5. Aufgabenabbruch

Bei der Verwendung von Thread im vorherigen Artikel haben wir eine Variable verwendet isStop-Markierung Unabhängig davon, ob die Aufgabe abgebrochen werden soll oder nicht, führt diese Methode des Zugriffs auf gemeinsam genutzte Variablen unweigerlich zu Problemen. Die Klasse „CancellationTokenSource“ wird in der Aufgabe vorgeschlagen, um den Aufgabenabbruch speziell zu behandeln. Informationen zur allgemeinen Verwendung finden Sie in den Codekommentaren unten

CancellationTokenSource source = new CancellationTokenSource();//构造函数中也可指定延迟取消
//注册一个取消时调用的委托
source.Token.Register(() =>
{
    Console.WriteLine("当前source已经取消，可以在这里做一些其他事情（比如资源清理）...");
});
var task1 = new Task(() => 
{
    while (!source.IsCancellationRequested)
    {
        Console.WriteLine($"task1 id={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}");
    }
},source.Token);
task1.Start();
//source.Cancel();//取消
source.CancelAfter(1000);//延时取消

6. Aufgabenergebnisse

让子线程返回结果，可以将信息写入到线程安全的共享变量中去，或则使用可以返回结果的任务。使用Task的泛型版本Taskb54c2c292509147c0b54128f4eb90887，就可以定义返回结果的任务。Task是继承自Task的，Result获取结果时是要阻塞等待直到任务完成返回结果的，内部判断没有完成则wait。通过TaskStatus属性可获得此任务的状态是启动、运行、异常还是取消等

var task = new Task<string>(() =>
{
     return "hello ketty";
});
task.Start();
string result = task.Result;

7、异常

可以使用AggregateException来接受任务中的异常信息，这是一个聚合异常继承自Exception，可以遍历获取包含的所有异常，以及进行异常处理，决定是否继续往上抛异常等

var task = Task.Factory.StartNew(() =>
{
    var childTask1 = Task.Factory.StartNew(() =>
    {
        throw new Exception("childTask1异常...");
    },TaskCreationOptions.AttachedToParent);
    var childTask12= Task.Factory.StartNew(() =>
    {
        throw new Exception("childTask2异常...");
    }, TaskCreationOptions.AttachedToParent);
});
try
{
    try
    {
        task.Wait();
    }
    catch (AggregateException ex)
    {
        foreach (var item in ex.InnerExceptions)
        {
            Console.WriteLine($"message{item.InnerException.Message}");
        }
        ex.Handle(x =>
        {
            if (x.InnerException.Message == "childTask1异常...")
            {
                return true;//异常被处理，不继续往上抛了
            }
            return false;
        });
    }
}
catch (Exception ex)
{
    throw;
}

二、并行Parallel

1、Parallel.For()、Parallel.ForEach()

在.NET4中，另一个新增的抽象的线程时Parallel类。这个类定义了并行的for和foreach的静态方法。Parallel.For()和Parallel.ForEach()方法多次调用一个方法，而Parallel.Invoke()方法允许同时调用不同的方法。首先Parallel是会阻塞主线程的，它将让主线程也参与到任务中

Parallel.For()类似于for允许语句，并行迭代同一个方法，迭代顺序没有保证的

ParallelLoopResult result = Parallel.For(0, 10, i =>
{
    Console.WriteLine($"{i} task:{Task.CurrentId} thread:{Thread.CurrentThread.ManagedThreadId}");
});
Console.WriteLine(result.IsCompleted);

也可以提前中断Parallel.For()方法。For()方法的一个重载版本接受Action0b577780dcee67a906216f9ca0bee521类型参数。一般不使用，像下面这样，本想大于5就停止，但实际也可能有大于5的任务已经在跑了。可以通过ParallelOptions传入允许最大线程数以及取消Token等

ParallelLoopResult result = Parallel.For(0, 10, new ParallelOptions() { MaxDegreeOfParallelism = 8 },(i,loop) =>
{
    Console.WriteLine($"{i} task:{Task.CurrentId} thread:{Thread.CurrentThread.ManagedThreadId}");
    if (i > 5)
    {
        loop.Break();
    }
});

2、Parallel.For484ebffe0129924a37882ea651634562

For还有一个高级泛型版本，相当于并行的聚合计算

ParallelLoopResult For<TLocal>(int fromInclusive, int toExclusive, Func<TLocal> localInit, Func<int, ParallelLoopState, TLocal, TLocal> body, Action<TLocal> localFinally);

像下面这样我们求0…100的和，第三个参数更定一个种子初始值，第四个参数迭代累计，最后聚合

int totalNum = 0;
Parallel.For<int>(0, 100, () => { return 0; }, (current, loop, total) =>
{
    total += current;
    return total;
}, (total) =>
{
    Interlocked.Add(ref totalNum, total);
});

上面For用来处理数组数据，ForEach()方法用来处理非数组的数据任务，比如字典数据继承自IEnumerable的集合等

3、Parallel.Invoke()

Parallel.Invoke()则可以并行调用不同的方法，参数传递一个Action的委托数组

Parallel.Invoke(() => { Console.WriteLine($"方法1 thread:{Thread.CurrentThread.ManagedThreadId}"); }
    , () => { Console.WriteLine($"方法2 thread:{Thread.CurrentThread.ManagedThreadId}"); }
    , () => { Console.WriteLine($"方法3 thread:{Thread.CurrentThread.ManagedThreadId}"); });

4、PLinq

Plinq，为了能够达到最大的灵活度，linq有了并行版本。使用也很简单，只需要将原始集合AsParallel就转换为支持并行化的查询。也可以AsOrdered来顺序执行，取消Token，强制并行等

var nums = Enumerable.Range(0, 100);
var query = from n in nums.AsParallel()
            select new
            {
                thread=$"tid={Thread.CurrentThread.ManagedThreadId},datetime={DateTime.Now}"
            };

三、异步等待AsyncAwait

异步编程模型，可能还需要大篇幅来学习，这里先介绍下基本用法，内在本质需要用ILSpy反编译来看，以后可能要分专题总结。文末先给几个参考资料，有兴趣自己阔以先琢磨琢磨鸭

1、简单使用

这是.NET4.5开始提供的一对语法糖，使得可以较简便的使用异步编程。async用在方法定义前面，await只能写在带有async标记的方法中，任何方法都可以增加async，一般成对出现，只有async没有意义，只有await会报错，请先看下面的示例

private static async void AsyncTest()
{
    //主线程执行
    Console.WriteLine($"before await ThreadId={Thread.CurrentThread.ManagedThreadId}");
    TaskFactory taskFactory = new TaskFactory();
    Task task = taskFactory.StartNew(() =>
    {
        Thread.Sleep(3000);
        Console.WriteLine($"task ThreadId={Thread.CurrentThread.ManagedThreadId}");
    });
    await task;//主线程到这里就返回了，执行主线程任务
    //子线程执行，其实是封装成委托，在task之后成为回调（编译器功能  状态机实现） 后面相当于task.ContinueWith()
    //这个回调的线程是不确定的：可能是主线程  可能是子线程  也可能是其他线程，在winform中是主线程
    Console.WriteLine($"after await ThreadId={Thread.CurrentThread.ManagedThreadId}");
}

一般使用async都会让方法返回一个Task的，像下面这样复杂一点的

private static async Task<string> AsyncTest2()
{
    Console.WriteLine($"before await ThreadId={Thread.CurrentThread.ManagedThreadId}");
    TaskFactory taskFactory = new TaskFactory();
    string x = await taskFactory.StartNew(() =>
      {
          Thread.Sleep(3000);
          Console.WriteLine($"task ThreadId={Thread.CurrentThread.ManagedThreadId}");
          return "task over";
      });
    Console.WriteLine($"after await ThreadId={Thread.CurrentThread.ManagedThreadId}");
    return x;
}

通过var reslult = AsyncTest2().Result;调用即可。但注意如果调用Wait或Result的代码位于UI线程，Task的实际执行在其他线程，其需要返回UI线程则会造成死锁，所以应该Async all the way

2、优雅

从上面简单示例中可以看出异步编程的执行逻辑：主线程A逻辑->异步任务线程B逻辑->主线程C逻辑。

异步方法的返回类型只能是void、Task、Task。示例中异步方法的返回值类型是Task，通常void也不推荐使用，没有返回值直接用Task就是

上一篇也大概了解到如果我们要在任务中更新UI，需要调用Invoke通知UI线程来更新，代码看起来像下面这样，在一个任务后去更新UI

private void button1_Click(object sender, EventArgs e)
{
    var ResultTask = Task.Run(() => {
        Thread.Sleep(5000);
        return "任务完成";
    });
    ResultTask.ContinueWith((r)=> 
    {
        textBox1.Invoke(() => {
            textBox1.Text = r.Result;
        });
    });
}

如果使用async/await会看起来像这样，是不是优雅了许多。以看似同步编程的方式实现异步

private async void button1_Click(object sender, EventArgs e)
{
    var t = Task.Run(() => {
        Thread.Sleep(5000);
        return "任务完成";
    });
    textBox1.Text = await t;
}

3、最后

在.NET 4.5中引入的Async和Await两个新的关键字后，用户能以一种简洁直观的方式实现异步编程。甚至都不需要改变代码的逻辑结构，就能将原来的同步函数改造为异步函数。

在内部实现上，Async和Await这两个关键字由编译器转换为状态机，通过System.Threading.Tasks中的并行类实现代码的异步执行。

本文来自 C#.Net教程 栏目，欢迎学习！  

Das obige ist der detaillierte Inhalt vonasynchron asynchron, Thread-Multithreading in .NET. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!