TaskScheduler Sınıf
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
İş parçacıklarında görevleri kuyruğa alma alt düzey çalışmasını işleyen bir nesneyi temsil eder.
public ref class TaskScheduler abstractpublic abstract class TaskSchedulertype TaskScheduler = classPublic MustInherit Class TaskScheduler- Devralma
-
TaskScheduler
Örnekler
Aşağıdaki örnek, uygulama tarafından kullanılan iş parçacığı sayısını sınırlayan özel bir görev zamanlayıcı oluşturur. Ardından iki görev kümesi başlatır ve görevin yürütülmekte olduğu görev ve iş parçacığı hakkındaki bilgileri görüntüler.
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
class Example
{
static void Main()
{
// Create a scheduler that uses two threads.
LimitedConcurrencyLevelTaskScheduler lcts = new LimitedConcurrencyLevelTaskScheduler(2);
List<Task> tasks = new List<Task>();
// Create a TaskFactory and pass it our custom scheduler.
TaskFactory factory = new TaskFactory(lcts);
CancellationTokenSource cts = new CancellationTokenSource();
// Use our factory to run a set of tasks.
Object lockObj = new Object();
int outputItem = 0;
for (int tCtr = 0; tCtr <= 4; tCtr++) {
int iteration = tCtr;
Task t = factory.StartNew(() => {
for (int i = 0; i < 1000; i++) {
lock (lockObj) {
Console.Write("{0} in task t-{1} on thread {2} ",
i, iteration, Thread.CurrentThread.ManagedThreadId);
outputItem++;
if (outputItem % 3 == 0)
Console.WriteLine();
}
}
}, cts.Token);
tasks.Add(t);
}
// Use it to run a second set of tasks.
for (int tCtr = 0; tCtr <= 4; tCtr++) {
int iteration = tCtr;
Task t1 = factory.StartNew(() => {
for (int outer = 0; outer <= 10; outer++) {
for (int i = 0x21; i <= 0x7E; i++) {
lock (lockObj) {
Console.Write("'{0}' in task t1-{1} on thread {2} ",
Convert.ToChar(i), iteration, Thread.CurrentThread.ManagedThreadId);
outputItem++;
if (outputItem % 3 == 0)
Console.WriteLine();
}
}
}
}, cts.Token);
tasks.Add(t1);
}
// Wait for the tasks to complete before displaying a completion message.
Task.WaitAll(tasks.ToArray());
cts.Dispose();
Console.WriteLine("\n\nSuccessful completion.");
}
}
// Provides a task scheduler that ensures a maximum concurrency level while
// running on top of the thread pool.
public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
{
// Indicates whether the current thread is processing work items.
[ThreadStatic]
private static bool _currentThreadIsProcessingItems;
// The list of tasks to be executed
private readonly LinkedList<Task> _tasks = new LinkedList<Task>(); // protected by lock(_tasks)
// The maximum concurrency level allowed by this scheduler.
private readonly int _maxDegreeOfParallelism;
// Indicates whether the scheduler is currently processing work items.
private int _delegatesQueuedOrRunning = 0;
// Creates a new instance with the specified degree of parallelism.
public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
{
if (maxDegreeOfParallelism < 1) throw new ArgumentOutOfRangeException("maxDegreeOfParallelism");
_maxDegreeOfParallelism = maxDegreeOfParallelism;
}
// Queues a task to the scheduler.
protected sealed override void QueueTask(Task task)
{
// Add the task to the list of tasks to be processed. If there aren't enough
// delegates currently queued or running to process tasks, schedule another.
lock (_tasks)
{
_tasks.AddLast(task);
if (_delegatesQueuedOrRunning < _maxDegreeOfParallelism)
{
++_delegatesQueuedOrRunning;
NotifyThreadPoolOfPendingWork();
}
}
}
// Inform the ThreadPool that there's work to be executed for this scheduler.
private void NotifyThreadPoolOfPendingWork()
{
ThreadPool.UnsafeQueueUserWorkItem(_ =>
{
// Note that the current thread is now processing work items.
// This is necessary to enable inlining of tasks into this thread.
_currentThreadIsProcessingItems = true;
try
{
// Process all available items in the queue.
while (true)
{
Task item;
lock (_tasks)
{
// When there are no more items to be processed,
// note that we're done processing, and get out.
if (_tasks.Count == 0)
{
--_delegatesQueuedOrRunning;
break;
}
// Get the next item from the queue
item = _tasks.First.Value;
_tasks.RemoveFirst();
}
// Execute the task we pulled out of the queue
base.TryExecuteTask(item);
}
}
// We're done processing items on the current thread
finally { _currentThreadIsProcessingItems = false; }
}, null);
}
// Attempts to execute the specified task on the current thread.
protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
// If this thread isn't already processing a task, we don't support inlining
if (!_currentThreadIsProcessingItems) return false;
// If the task was previously queued, remove it from the queue
if (taskWasPreviouslyQueued)
// Try to run the task.
if (TryDequeue(task))
return base.TryExecuteTask(task);
else
return false;
else
return base.TryExecuteTask(task);
}
// Attempt to remove a previously scheduled task from the scheduler.
protected sealed override bool TryDequeue(Task task)
{
lock (_tasks) return _tasks.Remove(task);
}
// Gets the maximum concurrency level supported by this scheduler.
public sealed override int MaximumConcurrencyLevel { get { return _maxDegreeOfParallelism; } }
// Gets an enumerable of the tasks currently scheduled on this scheduler.
protected sealed override IEnumerable<Task> GetScheduledTasks()
{
bool lockTaken = false;
try
{
Monitor.TryEnter(_tasks, ref lockTaken);
if (lockTaken) return _tasks;
else throw new NotSupportedException();
}
finally
{
if (lockTaken) Monitor.Exit(_tasks);
}
}
}
// The following is a portion of the output from a single run of the example:
// 'T' in task t1-4 on thread 3 'U' in task t1-4 on thread 3 'V' in task t1-4 on thread 3
// 'W' in task t1-4 on thread 3 'X' in task t1-4 on thread 3 'Y' in task t1-4 on thread 3
// 'Z' in task t1-4 on thread 3 '[' in task t1-4 on thread 3 '\' in task t1-4 on thread 3
// ']' in task t1-4 on thread 3 '^' in task t1-4 on thread 3 '_' in task t1-4 on thread 3
// '`' in task t1-4 on thread 3 'a' in task t1-4 on thread 3 'b' in task t1-4 on thread 3
// 'c' in task t1-4 on thread 3 'd' in task t1-4 on thread 3 'e' in task t1-4 on thread 3
// 'f' in task t1-4 on thread 3 'g' in task t1-4 on thread 3 'h' in task t1-4 on thread 3
// 'i' in task t1-4 on thread 3 'j' in task t1-4 on thread 3 'k' in task t1-4 on thread 3
// 'l' in task t1-4 on thread 3 'm' in task t1-4 on thread 3 'n' in task t1-4 on thread 3
// 'o' in task t1-4 on thread 3 'p' in task t1-4 on thread 3 ']' in task t1-2 on thread 4
// '^' in task t1-2 on thread 4 '_' in task t1-2 on thread 4 '`' in task t1-2 on thread 4
// 'a' in task t1-2 on thread 4 'b' in task t1-2 on thread 4 'c' in task t1-2 on thread 4
// 'd' in task t1-2 on thread 4 'e' in task t1-2 on thread 4 'f' in task t1-2 on thread 4
// 'g' in task t1-2 on thread 4 'h' in task t1-2 on thread 4 'i' in task t1-2 on thread 4
// 'j' in task t1-2 on thread 4 'k' in task t1-2 on thread 4 'l' in task t1-2 on thread 4
// 'm' in task t1-2 on thread 4 'n' in task t1-2 on thread 4 'o' in task t1-2 on thread 4
// 'p' in task t1-2 on thread 4 'q' in task t1-2 on thread 4 'r' in task t1-2 on thread 4
// 's' in task t1-2 on thread 4 't' in task t1-2 on thread 4 'u' in task t1-2 on thread 4
// 'v' in task t1-2 on thread 4 'w' in task t1-2 on thread 4 'x' in task t1-2 on thread 4
// 'y' in task t1-2 on thread 4 'z' in task t1-2 on thread 4 '{' in task t1-2 on thread 4
// '|' in task t1-2 on thread 4 '}' in task t1-2 on thread 4 '~' in task t1-2 on thread 4
// 'q' in task t1-4 on thread 3 'r' in task t1-4 on thread 3 's' in task t1-4 on thread 3
// 't' in task t1-4 on thread 3 'u' in task t1-4 on thread 3 'v' in task t1-4 on thread 3
// 'w' in task t1-4 on thread 3 'x' in task t1-4 on thread 3 'y' in task t1-4 on thread 3
// 'z' in task t1-4 on thread 3 '{' in task t1-4 on thread 3 '|' in task t1-4 on thread 3
Açıklamalar
TaskScheduler sınıfı bir görev zamanlayıcısını temsil eder. Görev zamanlayıcı, bir görevin çalışmasının sonunda yürütülmesini sağlar.
Varsayılan görev zamanlayıcı yük dengeleme için iş çalma, maksimum aktarım hızı için iş parçacığı ekleme/kullanımdan kaldırma ve genel olarak iyi performans sağlar. Çoğu senaryo için yeterli olmalıdır.
sınıfı TaskScheduler ayrıca tüm özelleştirilebilir zamanlama mantığı için uzantı noktası görevi görür. Bu, bir görevin yürütülmesi için nasıl zamanlandığı ve zamanlanmış görevlerin hata ayıklayıcılara nasıl gösterileceği gibi mekanizmaları içerir. Özel işlevlere ihtiyacınız varsa, özel bir zamanlayıcı oluşturabilir ve bunu belirli görevler veya sorgular için etkinleştirebilirsiniz.
Varsayılan görev zamanlayıcı ve iş parçacığı havuzu
Görev Paralel Kitaplığı ve PLINQ için varsayılan zamanlayıcı, işi kuyruğa almak ve yürütmek için ThreadPool sınıfı tarafından temsil edilen .NET iş parçacığı havuzunu kullanır. İş parçacığı havuzu, paralel görevlerin ve sorguların sıklıkla temsil ettiği kısa ömürlü iş birimlerini içeren ayrıntılı paralelliği verimli bir şekilde desteklemek için Task türünden sağlanan bilgileri kullanır.
Genel kuyruk ile yerel kuyruklar karşılaştırması
İş parçacığı havuzu, her uygulama etki alanındaki iş parçacıkları için genel bir FIFO (ilk gelen ilk çıkar) iş kuyruğu tutar. Bir program ThreadPool.QueueUserWorkItem (veya ThreadPool.UnsafeQueueUserWorkItem) yöntemini her çağırdığında, iş bu paylaşılan kuyruğa alınır ve sonunda uygun olan herhangi bir iş parçacığında çalıştırılır. .NET Framework 4'den başlayarak bu kuyruk, sınıfına ConcurrentQueue<T> benzeyen bir kilitsiz algoritma kullanır. İş parçacığı havuzu, bu kilitsiz uygulamayı kullanarak iş öğelerini kuyruğa alıp kuyruklarından çıkardığında daha az zaman harcar. Bu performans avantajı, iş parçacığı havuzunu kullanan tüm programlar tarafından kullanılabilir.
Başka bir görev bağlamında oluşturulmayan görevler olan üst düzey görevler, diğer iş öğeleri gibi genel kuyruğa konur. Ancak, başka bir görev bağlamında oluşturulan iç içe veya alt görevler oldukça farklı işlenir. Alt veya iç içe görev, üst görevin yürütülmekte olduğu iş parçacığına özgü yerel bir kuyruğa konur. Ana görev, üst düzey bir görev olabileceği gibi başka bir görevin alt görevi de olabilir. Bu iş parçacığı daha fazla çalışmaya hazır olduğunda, önce yerel kuyruğa bakar. İş öğeleri orada bekliyorsa, bunlara hızlı bir şekilde erişilebilir. Önbellek yerelliğini korumak ve çekişmeleri azaltmak amacıyla, yerel kuyruklara son giren ilk çıkar (LIFO) sırasına göre erişilir. Alt görevler ve iç içe görevler hakkında daha fazla bilgi için bkz. Bağlı ve Bağımsız Alt Görevler.
Yerel kuyrukların kullanılması yalnızca genel kuyruk üzerindeki baskıyı azaltmakla kalmaz, aynı zamanda veri yerelliğinden de yararlanır. Yerel kuyruktaki iş öğeleri genellikle bellekte fiziksel olarak birbirine yakın olan veri yapılarına başvurur. Bu gibi durumlarda, ilk görev çalıştırıldıktan sonra veriler zaten önbellektedir ve bunlara hızlı bir şekilde erişilebilir. Hem Paralel LINQ (PLINQ) hem de Parallel sınıfı iç içe görevleri ve alt görevleri yoğun bir şekilde kullanır ve yerel iş kuyruklarını kullanarak önemli hız artışları elde eder.
İş çalma
.NET Framework 4'den başlayarak iş parçacığı havuzu, başkalarının kuyruklarında çalışmaya devam ederken hiçbir iş parçacığının boşta kalmadığından emin olmak için bir iş parçacığı çalma algoritması da içerir. Havuzdaki iş parçacığı daha fazla çalışmaya hazır olduğunda, önce yerel kuyruğunun başına, sonra genel kuyruğa ve ardından diğer iş parçacıklarının yerel kuyruklarına bakar. Başka bir iş parçacığının yerel kuyruğunda bir iş öğesi bulursa, önce işi verimli bir şekilde çalıştırabileceğinden emin olmak için buluşsal yöntemler uygular. Eğer yapabilirse, iş öğesini FIFO sırasına göre kuyruğun sonundan kaldırır. Bu, her yerel kuyrukta çekişmesini azaltır ve veri yerelliğini korur. Bu mimari, iş parçacığı havuzunun yük dengelemesini önceki sürümlerden daha verimli hale getirir.
Uzun süreli görevler
Bir görevin yerel kuyruğa alınmasını açıkça engellemek isteyebilirsiniz. Örneğin, belirli bir iş öğesinin nispeten uzun süre çalışacağını ve büyük olasılıkla yerel kuyruktaki diğer tüm iş öğelerini engelleyebileceğini biliyor olabilirsiniz. Bu durumda, zamanlayıcıya System.Threading.Tasks.TaskCreationOptions görev için ek bir iş parçacığı gerekebileceğine dair bir ipucu sağlayan seçeneğini belirtebilirsiniz, böylece yerel kuyruktaki diğer iş parçacıklarının veya iş öğelerinin ilerleme durumunu engellemez. Bu seçeneği kullanarak, genel ve yerel kuyruklar dahil olmak üzere iş parçacığı havuzundan tamamen kaçınabilirsiniz.
Görev Satır İçi
Bazı durumlarda, Task beklenirken, bekleme operasyonunu gerçekleştiren iş parçacığında eşzamanlı olarak yürütülebilir. Bu, ek iş parçacığı gereksinimini önleyerek ve bunun yerine aksi takdirde engellenen mevcut iş parçacığını kullanarak performansı artırır. Yeniden giriş nedeniyle oluşan hataları önlemek için, görev içeriği yalnızca ilgili iş parçacığının yerel kuyruğunda bekleme hedefine rastlandığında tamamlanır.
Eşitleme bağlamı belirtme
Bir görevin belirli bir iş parçacığında çalışacak şekilde zamanlanması gerektiğini belirtmek için yöntemini kullanabilirsiniz TaskScheduler.FromCurrentSynchronizationContext . Bu, kullanıcı arabirimi nesnelerine erişimin genellikle ui nesnesinin oluşturulduğu iş parçacığında çalışan kodla sınırlı olduğu Windows Forms ve Windows Presentation Foundation gibi çerçevelerde kullanışlıdır.
Aşağıdaki örnek, bir Windows Presentation Foundation (WPF) uygulamasında TaskScheduler.FromCurrentSynchronizationContext yöntemini, kullanıcı arabirimi (UI) denetiminin oluşturulduğu aynı iş parçacığında bir görev zamanlamak için kullanır. Örnek, belirtilen dizinden rastgele seçilen görüntülerin mozaiğini oluşturur. WPF nesneleri görüntüleri yüklemek ve yeniden boyutlandırmak için kullanılır. Ham pikseller daha sonra piksel verilerini büyük bir tek baytlık diziye yazmak için döngü kullanan For bir göreve geçirilir. İki kutucuk aynı dizi öğelerini kaplamadığı için eşitleme gerekmez. Konumları diğer kutucuklardan bağımsız olarak hesaplandığından kutucuklar herhangi bir sırayla da yazılabilir. Daha sonra büyük dizi, piksel verilerinin görüntü denetimine yüklendiği UI iş parçacığında çalışan bir göreve geçirilir.
Örnek, verileri UI iş parçacığından taşır, paralel döngüler ve Task nesneler kullanarak değiştirir ve sonra ui iş parçacığında çalışan bir göreve geri geçirir. Bu yaklaşım, WPF API tarafından desteklenmeyen veya yeterince hızlı olmayan işlemleri gerçekleştirmek için Görev Paralel Kitaplığı'nı kullanmanız gerektiğinde kullanışlıdır. WPF'de görüntü mozaiği oluşturmanın bir diğer yolu da bir System.Windows.Controls.WrapPanel denetim kullanmak ve buna görüntü eklemektir. WrapPanel kutucukları konumlandırma işini halleder. Ancak, bu iş yalnızca kullanıcı arabirimi iş parçacığında gerçekleştirilebilir.
using System;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;
namespace WPF_CS1
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
private int fileCount;
int colCount;
int rowCount;
private int tilePixelHeight;
private int tilePixelWidth;
private int largeImagePixelHeight;
private int largeImagePixelWidth;
private int largeImageStride;
PixelFormat format;
BitmapPalette palette = null;
public MainWindow()
{
InitializeComponent();
// For this example, values are hard-coded to a mosaic of 8x8 tiles.
// Each tile is 50 pixels high and 66 pixels wide and 32 bits per pixel.
colCount = 12;
rowCount = 8;
tilePixelHeight = 50;
tilePixelWidth = 66;
largeImagePixelHeight = tilePixelHeight * rowCount;
largeImagePixelWidth = tilePixelWidth * colCount;
largeImageStride = largeImagePixelWidth * (32 / 8);
this.Width = largeImagePixelWidth + 40;
image.Width = largeImagePixelWidth;
image.Height = largeImagePixelHeight;
}
private void button_Click(object sender, RoutedEventArgs e)
{
// For best results use 1024 x 768 jpg files at 32bpp.
string[] files = System.IO.Directory.GetFiles(@"C:\Users\Public\Pictures\Sample Pictures\", "*.jpg");
fileCount = files.Length;
Task<byte[]>[] images = new Task<byte[]>[fileCount];
for (int i = 0; i < fileCount; i++)
{
int x = i;
images[x] = Task.Factory.StartNew(() => LoadImage(files[x]));
}
// When they've all been loaded, tile them into a single byte array.
var tiledImage = Task.Factory.ContinueWhenAll(
images, (i) => TileImages(i));
// We are currently on the UI thread. Save the sync context and pass it to
// the next task so that it can access the UI control "image".
var UISyncContext = TaskScheduler.FromCurrentSynchronizationContext();
// On the UI thread, put the bytes into a bitmap and
// display it in the Image control.
var t3 = tiledImage.ContinueWith((antecedent) =>
{
// Get System DPI.
Matrix m = PresentationSource.FromVisual(Application.Current.MainWindow)
.CompositionTarget.TransformToDevice;
double dpiX = m.M11;
double dpiY = m.M22;
BitmapSource bms = BitmapSource.Create(largeImagePixelWidth,
largeImagePixelHeight,
dpiX,
dpiY,
format,
palette, //use default palette
antecedent.Result,
largeImageStride);
image.Source = bms;
}, UISyncContext);
}
byte[] LoadImage(string filename)
{
// Use the WPF BitmapImage class to load and
// resize the bitmap. NOTE: Only 32bpp formats are supported correctly.
// Support for additional color formats is left as an exercise
// for the reader. For more information, see documentation for ColorConvertedBitmap.
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.UriSource = new Uri(filename);
bitmapImage.DecodePixelHeight = tilePixelHeight;
bitmapImage.DecodePixelWidth = tilePixelWidth;
bitmapImage.EndInit();
format = bitmapImage.Format;
int size = (int)(bitmapImage.Height * bitmapImage.Width);
int stride = (int)bitmapImage.Width * 4;
byte[] dest = new byte[stride * tilePixelHeight];
bitmapImage.CopyPixels(dest, stride, 0);
return dest;
}
int Stride(int pixelWidth, int bitsPerPixel)
{
return (((pixelWidth * bitsPerPixel + 31) / 32) * 4);
}
// Map the individual image tiles to the large image
// in parallel. Any kind of raw image manipulation can be
// done here because we are not attempting to access any
// WPF controls from multiple threads.
byte[] TileImages(Task<byte[]>[] sourceImages)
{
byte[] largeImage = new byte[largeImagePixelHeight * largeImageStride];
int tileImageStride = tilePixelWidth * 4; // hard coded to 32bpp
Random rand = new Random();
Parallel.For(0, rowCount * colCount, (i) =>
{
// Pick one of the images at random for this tile.
int cur = rand.Next(0, sourceImages.Length);
byte[] pixels = sourceImages[cur].Result;
// Get the starting index for this tile.
int row = i / colCount;
int col = (int)(i % colCount);
int idx = ((row * (largeImageStride * tilePixelHeight)) + (col * tileImageStride));
// Write the pixels for the current tile. The pixels are not contiguous
// in the array, therefore we have to advance the index by the image stride
// (minus the stride of the tile) for each scanline of the tile.
int tileImageIndex = 0;
for (int j = 0; j < tilePixelHeight; j++)
{
// Write the next scanline for this tile.
for (int k = 0; k < tileImageStride; k++)
{
largeImage[idx++] = pixels[tileImageIndex++];
}
// Advance to the beginning of the next scanline.
idx += largeImageStride - tileImageStride;
}
});
return largeImage;
}
}
}
Örneği oluşturmak için Visual Studio'da bir WPF uygulama projesi oluşturun ve bunu WPF_CS1 (C# WPF projesi için) veya WPF_VB1 (Visual Basic WPF projesi için) adlandırın. Ardından şunları yapın:
Tasarım görünümünde, Image bir denetimi tasarım yüzeyinin sol üst köşesine sürükleyin. Özellikler penceresinin Ad metin kutusunda denetimi "görüntü" olarak adlandırın.
Button bir denetimi uygulama penceresinin sol alt kısmına sürükleyin. XAML görünümünde düğmenin Content özelliğini "Mozaik yap" olarak belirtin ve özelliğini "100" olarak belirtin Width . Örneğin kodunda tanımlanan Click olay işleyicisi ile
button_ClickolayınıClick="button_Click"öğesine<Button>ekleyerek bağlayın. Özellikler penceresinin Ad metin kutusunda denetimi "düğme" olarak adlandırın.MainWindow.xaml.cs veya MainWindow.xaml.vb dosyasının tüm içeriğini bu örnekteki kodla değiştirin. C# WPF projesi için, çalışma alanının adının proje adıyla eşleştiğinden emin olun.
Örnek , C:\Users\Public\Pictures\Sample Pictures adlı dizinden JPEG görüntülerini okur. Dizini oluşturun ve bazı görüntüler yerleştirin veya yolu görüntü içeren başka bir dizine başvuracak şekilde değiştirin.
Bu örnekte bazı sınırlamalar vardır. Örneğin, yalnızca piksel başına 32 bit görüntüler desteklenir; Diğer biçimlerdeki görüntüler, yeniden boyutlandırma işlemi sırasında nesne tarafından BitmapImage bozulur. Ayrıca, her bir kaynak görüntü kutucuk boyutundan büyük olmalıdır. Daha fazla alıştırmada birden çok piksel biçimini ve dosya boyutunu işlemek için işlevsellik ekleyebilirsiniz.
Oluşturucular
| Name | Description |
|---|---|
| TaskScheduler() |
TaskScheduleröğesini başlatır. |
Özellikler
| Name | Description |
|---|---|
| Current |
TaskScheduler Şu anda yürütülmekte olan görevle ilişkili olan öğesini alır. |
| Default |
.NET tarafından sağlanan varsayılan TaskScheduler örneğini alır. |
| Id |
Bu TaskScheduleriçin benzersiz kimliği alır. |
| MaximumConcurrencyLevel |
Bunun TaskScheduler destekleyebileceği en yüksek eşzamanlılık düzeyini gösterir. |
Yöntemler
| Name | Description |
|---|---|
| Equals(Object) |
Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object) |
| Finalize() |
Bu zamanlayıcıyla ilişkili tüm kaynakları serbesttir. |
| FromCurrentSynchronizationContext() |
Geçerli TaskSchedulerile ilişkili bir SynchronizationContext oluşturur. |
| GetHashCode() |
Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object) |
| GetScheduledTasks() |
Yalnızca hata ayıklayıcı desteği için, yürütülmeyi bekleyen zamanlayıcıya sıraya alınmış örneklerin Task bir numaralandırılabilirini oluşturur. |
| GetType() |
Geçerli örneğin Type alır. (Devralındığı yer: Object) |
| MemberwiseClone() |
Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object) |
| QueueTask(Task) |
Zamanlayıcıya a Task kuyruğu oluşturur. |
| ToString() |
Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object) |
| TryDequeue(Task) |
Daha önce bu zamanlayıcıya kuyruğa alınmış bir Task sorguyu kaldırmaya çalışır. |
| TryExecuteTask(Task) |
Bu zamanlayıcıda sağlanan Task öğesini yürütmeye çalışır. |
| TryExecuteTaskInline(Task, Boolean) |
Sağlanan Task öğesinin bu çağrıda zaman uyumlu olarak yürütülip yürütülemeyeceğini belirler ve yürütebilirse yürütür. |
Ekinlikler
| Name | Description |
|---|---|
| UnobservedTaskException |
Hataya neden olan bir görevin gözlemlenmeyen özel durumu, varsayılan olarak işlemi sonlandıracak özel durum yükseltme ilkesini tetiklemek üzere olduğunda gerçekleşir. |
Şunlara uygulanır
İş Parçacığı Güvenliği
Soyut TaskScheduler türün tüm üyeleri iş parçacığı açısından güvenlidir ve aynı anda birden çok iş parçacığından kullanılabilir.
