Task.RunSynchronously Metoda
Definice
Důležité
Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.
Spustí synchronně Task na aktuální TaskScheduler.
Přetížení
RunSynchronously(TaskScheduler) |
Spustí synchronně Task na zadaném TaskScheduler zařízení. |
RunSynchronously() |
Spustí synchronně Task na aktuální TaskScheduler. |
RunSynchronously(TaskScheduler)
Spustí synchronně Task na zadaném TaskScheduler zařízení.
public:
void RunSynchronously(System::Threading::Tasks::TaskScheduler ^ scheduler);
public void RunSynchronously (System.Threading.Tasks.TaskScheduler scheduler);
member this.RunSynchronously : System.Threading.Tasks.TaskScheduler -> unit
Public Sub RunSynchronously (scheduler As TaskScheduler)
Parametry
- scheduler
- TaskScheduler
Plánovač, ve kterém se má pokusit spustit tuto úlohu přímo.
Výjimky
Instance Task byla odstraněna.
Argument scheduler
je null
.
Není Task v platném stavu, který by se spustil. Je možné, že již byla spuštěna, spuštěna nebo zrušena, nebo může být vytvořena způsobem, který nepodporuje přímé plánování.
Poznámky
Úlohy spuštěné voláním RunSynchronously metody se vytvoří vytvořením instance voláním konstruktoru Task třídy nebo Task<TResult> . Úloha, která se má spustit synchronně, musí být ve Created stavu . Úloha může být spuštěna a spuštěna pouze jednou. Při každém druhém pokusu o naplánování úkolu dojde k výjimce.
Pokud cílový plánovač nepodporuje spuštění této úlohy v aktuálním vlákně, bude naplánováno spuštění úlohy v plánovači a aktuální vlákno bude blokováno, dokud se úkol nedokončil. Z tohoto důvodu volající vlákno nemusí volat metodu, jako Wait je zajištění, že úloha dokončila provádění. Další informace o zpracování výjimek pro operace úloh najdete v tématu Zpracování výjimek.
Viz také
Platí pro
RunSynchronously()
Spustí synchronně Task na aktuální TaskScheduler.
public:
void RunSynchronously();
public void RunSynchronously ();
member this.RunSynchronously : unit -> unit
Public Sub RunSynchronously ()
Výjimky
Instance Task byla odstraněna.
Není Task v platném stavu, který by se spustil. Je možné, že již byla spuštěna, spuštěna nebo zrušena, nebo může být vytvořena způsobem, který nepodporuje přímé plánování.
Příklady
Následující příklad porovnává úlohu spuštěnou voláním RunSynchronously metody s jednou spuštěnou asynchronně. V obou případech úlohy spouštějí identické výrazy lambda, které zobrazují ID úlohy a ID vlákna, na kterém je úloha spuštěna. Úkol vypočítá součet celých čísel mezi 1 a 1 000 000. Jak ukazuje výstup z příkladu, úloha spuštěná voláním RunSynchronously metody běží ve vlákně aplikace, zatímco asynchronní úloha ne.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
Console.WriteLine("Application executing on thread {0}",
Thread.CurrentThread.ManagedThreadId);
var asyncTask = Task.Run( () => { Console.WriteLine("Task {0} (asyncTask) executing on Thread {1}",
Task.CurrentId,
Thread.CurrentThread.ManagedThreadId);
long sum = 0;
for (int ctr = 1; ctr <= 1000000; ctr++ )
sum += ctr;
return sum;
});
var syncTask = new Task<long>( () => { Console.WriteLine("Task {0} (syncTask) executing on Thread {1}",
Task.CurrentId,
Thread.CurrentThread.ManagedThreadId);
long sum = 0;
for (int ctr = 1; ctr <= 1000000; ctr++ )
sum += ctr;
return sum;
});
syncTask.RunSynchronously();
Console.WriteLine();
Console.WriteLine("Task {0} returned {1:N0}", syncTask.Id, syncTask.Result);
Console.WriteLine("Task {0} returned {1:N0}", asyncTask.Id, asyncTask.Result);
}
}
// The example displays the following output:
// Application executing on thread 1
// Task 1 (syncTask) executing on Thread 1
// Task 2 (asyncTask) executing on Thread 3
// 1 status: RanToCompletion
// 2 status: RanToCompletion
//
// Task 2 returned 500,000,500,000
// Task 1 returned 500,000,500,000
open System
open System.Threading
open System.Threading.Tasks
printfn $"Application executing on thread {Thread.CurrentThread.ManagedThreadId}"
let asyncTask =
Task.Run(fun () ->
printfn $"Task {Task.CurrentId} (asyncTask) executing on Thread {Thread.CurrentThread.ManagedThreadId}"
let mutable sum = 0L
for i = 1 to 1000000 do
sum <- sum + int64 i
sum)
let syncTask =
new Task<int64>(fun () ->
printfn $"Task {Task.CurrentId} (syncTask) executing on Thread {Thread.CurrentThread.ManagedThreadId}"
let mutable sum = 0L
for i = 1 to 1000000 do
sum <- sum + int64 i
sum)
syncTask.RunSynchronously()
printfn $"\nTask {syncTask.Id} returned {syncTask.Result:N0}"
printfn $"Task {asyncTask.Id} returned {asyncTask.Result:N0}"
// The example displays the following output:
// Application executing on thread 1
// Task 1 (syncTask) executing on Thread 1
// Task 2 (asyncTask) executing on Thread 3
// 1 status: RanToCompletion
// 2 status: RanToCompletion
//
// Task 2 returned 500,000,500,000
// Task 1 returned 500,000,500,000
Imports System.Threading
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Console.WriteLine("Application executing on thread {0}",
Thread.CurrentThread.ManagedThreadId)
Dim asyncTask = Task.Run( Function()
Console.WriteLine("Task {0} (asyncTask) executing on Thread {1}",
Task.CurrentId,
Thread.CurrentThread.ManagedThreadId)
Dim sum As Long = 0
For ctr As Integer = 1 To 1000000
sum += ctr
Next
Return sum
End Function)
Dim syncTask As New Task(Of Long)( Function()
Console.WriteLine("Task {0} (syncTask) executing on Thread {1}",
Task.CurrentId,
Thread.CurrentThread.ManagedThreadId)
Dim sum As Long = 0
For ctr As Integer = 1 To 1000000
sum += ctr
Next
Return sum
End Function)
syncTask.RunSynchronously()
Console.WriteLine()
Console.WriteLine("Task {0} returned {1:N0}", syncTask.Id, syncTask.Result)
Console.WriteLine("Task {0} returned {1:N0}", asyncTask.Id, asyncTask.Result)
End Sub
End Module
' The example displays the following output:
' Application executing on thread 1
' Task 1 (syncTask) executing on Thread 1
' Task 2 (asyncTask) executing on Thread 3
' 1 status: RanToCompletion
' 2 status: RanToCompletion
'
' Task 2 returned 500,000,500,000
' Task 1 returned 500,000,500,000
Poznámky
Úlohy se obvykle provádějí asynchronně ve vlákně fondu vláken a neblokují volající vlákno. Úlohy prováděné voláním RunSynchronously() metody jsou přidruženy k aktuálnímu TaskScheduler a jsou spuštěny ve volajícím vlákně. Pokud cílový plánovač nepodporuje spuštění této úlohy ve volajícím vlákně, bude naplánováno spuštění úlohy v plánovači a volající vlákno bude blokováno, dokud úloha nedokončila provádění. I když úloha běží synchronně, volající vlákno by mělo stále volat Wait , aby zvládlo všechny výjimky, které může úloha vyvolat. Další informace o zpracování výjimek najdete v tématu Zpracování výjimek.
Úlohy spuštěné voláním RunSynchronously metody se vytvoří vytvořením instance voláním konstruktoru Task třídy nebo Task<TResult> . Úloha, která se má spustit synchronně, musí být ve Created stavu . Úloha může být spuštěna a spuštěna pouze jednou. Při každém druhém pokusu o naplánování úkolu dojde k výjimce.
Viz také
Platí pro
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat Problémy GitHubu jako mechanismus zpětné vazby pro obsah a nahradíme ho novým systémem zpětné vazby. Další informace najdete tady:Odeslat a zobrazit názory pro