TaskScheduler Classe

Definição

public ref class TaskScheduler abstract

public abstract class TaskScheduler

type TaskScheduler = class

Public MustInherit Class TaskScheduler

Herança

Object

TaskScheduler

Exemplos

O exemplo a seguir cria um agendador de tarefas personalizado que limita o número de threads usados pelo aplicativo. Em seguida, ele inicia dois conjuntos de tarefas e exibe informações sobre a tarefa e o thread no qual a tarefa está sendo executada.

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

Comentários

A TaskScheduler classe representa um agendador de tarefas. Um agendador de tarefas garante que o trabalho de uma tarefa seja eventualmente executado.

O agendador de tarefas padrão oferece roubo de trabalho para balanceamento de carga, criação/desativação de threads para máxima eficiência e bom desempenho geral. Deve ser suficiente para a maioria dos cenários.

A TaskScheduler classe também serve como o ponto de extensão para toda a lógica de agendamento personalizável. Isso inclui mecanismos como como agendar uma tarefa para execução e como as tarefas agendadas devem ser expostas aos depuradores. Se você precisar de funcionalidade especial, poderá criar um agendador personalizado e habilitá-lo para tarefas ou consultas específicas.

O agendador de tarefas padrão e o pool de threads

O agendador padrão da Biblioteca Paralela de Tarefas e PLINQ usa o pool de threads do .NET, que é representado pela ThreadPool classe, para enfileirar e executar o trabalho. O pool de segmentos usa as informações fornecidas pelo tipo Task para dar suporte eficiente ao paralelismo granular (unidades de trabalho de curta duração) que tarefas e consultas paralelas geralmente representam.

A fila global versus filas locais

O pool de threads mantém uma fila global de primeiro a entrar, primeiro a sair (FIFO) para threads em cada domínio de aplicação. Sempre que um programa chama o método ThreadPool.QueueUserWorkItem (ou ThreadPool.UnsafeQueueUserWorkItem), o trabalho é colocado nessa fila compartilhada e, eventualmente, é removido da fila para o próximo thread que ficar disponível. A partir do .NET Framework 4, essa fila usa um algoritmo sem bloqueio que se assemelha à ConcurrentQueue<T> classe. Usando essa implementação sem bloqueio, o grupo de threads gasta menos tempo quando enfileira e desenfileira itens de trabalho. Esse benefício de desempenho está disponível para todos os programas que usam o pool de threads.

Tarefas de nível superior, que são tarefas que não são criadas no contexto de outra tarefa, são colocadas na fila global, assim como qualquer outro item de trabalho. No entanto, as tarefas aninhadas ou subtarefas, que são criadas no contexto de outra tarefa, são tratadas de maneira bastante diferente. Uma tarefa filho ou aninhada é colocada em uma fila local específica para o thread no qual a tarefa pai está sendo executada. A tarefa pai pode ser uma tarefa de nível superior ou igualmente pode ser filha de outra tarefa. Quando esse thread está pronto para mais trabalho, ele procura na fila local primeiro. Se os itens de trabalho estiverem aguardando lá, eles poderão ser acessados rapidamente. As filas locais são acessadas na ordem LIFO (último a entrar, primeiro a sair) para preservar a localidade de cache e reduzir a contenção. Para obter mais informações sobre tarefas filhas e tarefas aninhadas, consulte Tarefas filhas anexadas e desanexadas.

O uso de filas locais não apenas reduz a pressão na fila global, mas também aproveita a localidade dos dados. Os itens de trabalho na fila local frequentemente fazem referência a estruturas de dados que estão fisicamente próximas umas das outras na memória. Nesses casos, os dados já estão no cache após a execução da primeira tarefa e podem ser acessados rapidamente. Tanto o LINQ Paralelo (PLINQ) quanto a classe Parallel usam extensivamente tarefas aninhadas e tarefas filhas e obtêm melhorias consideráveis de desempenho usando as filas de trabalho locais.

Roubo de trabalho

A partir do .NET Framework 4, o pool de threads também incorpora um algoritmo de roubo de trabalho para ajudar a garantir que nenhuma thread fique ociosa enquanto outras ainda têm trabalho em suas filas. Quando um thread do pool de threads está pronto para mais trabalho, primeiro ele olha para o início de sua fila local, em seguida na fila global e depois nas filas locais de outros threads. Se encontrar um item de trabalho na fila local de outro thread, ele primeiro aplicará heurística para garantir que ele possa executar o trabalho de forma eficiente. Se puder, ele remove o item de trabalho do fim da fila (na ordem FIFO). Isso reduz a contenção em cada fila local e preserva a localidade dos dados. Essa arquitetura ajuda o trabalho de balanceamento de carga do pool de threads com mais eficiência do que as versões anteriores.

Tarefas de longa duração

Talvez você queira impedir explicitamente que uma tarefa seja colocada em uma fila local. Por exemplo, você pode saber que um item de trabalho específico será executado por um tempo relativamente longo e provavelmente bloqueará todos os outros itens de trabalho na fila local. Nesse caso, você pode especificar a opção System.Threading.Tasks.TaskCreationOptions , que fornece uma dica para o agendador de que um thread adicional pode ser necessário para a tarefa para que ela não bloqueie o progresso de outros threads ou itens de trabalho na fila local. Usando essa opção, você evita completamente o pool de threads, incluindo as filas globais e locais.

Inlining de tarefa

Em alguns casos, quando se está aguardando por um Task, ele pode ser executado de forma síncrona no thread que está executando a operação de espera. Isso aprimora o desempenho, evitando a necessidade de uma thread adicional e, em vez disso, usando a thread existente, que, de outra forma, estaria bloqueada. Para evitar erros devido à reentrância, a inlining de tarefas só ocorre quando o destino de espera é encontrado na fila local do thread relevante.

Especificar um contexto de sincronização

Você pode usar o TaskScheduler.FromCurrentSynchronizationContext método para especificar que uma tarefa deve ser agendada para ser executada em um thread específico. Isso é útil em estruturas como o Windows Forms e o Windows Presentation Foundation, em que o acesso a objetos de interface do usuário geralmente é restrito ao código em execução no mesmo thread no qual o objeto de interface do usuário foi criado.

O exemplo a seguir usa o TaskScheduler.FromCurrentSynchronizationContext método em um aplicativo WPF (Windows Presentation Foundation) para agendar uma tarefa no mesmo thread no qual o controle de interface do usuário (interface do usuário) foi criado. O exemplo cria um mosaico de imagens selecionadas aleatoriamente de um diretório especificado. Os objetos WPF são usados para carregar e redimensionar as imagens. Depois disso, os pixels brutos são passados para uma tarefa que usa um loop For para gravar os dados de pixel em uma grande matriz de bytes únicos. Nenhuma sincronização é necessária porque nenhum bloco ocupa os mesmos elementos de matriz. Os blocos também podem ser gravados em qualquer ordem porque sua posição é calculada independentemente de qualquer outro bloco. Em seguida, a matriz grande é passada para uma tarefa que é executada no thread da interface do usuário, em que os dados de pixel são carregados em um controle de imagem.

O exemplo move os dados da thread da interface do usuário, modifica-os usando loops paralelos e objetos Task e os passa de volta para uma tarefa que é executada na thread da interface do usuário. Essa abordagem é útil quando você precisa usar a Biblioteca Paralela de Tarefas para executar operações que não têm suporte na API do WPF ou não são suficientemente rápidas. Outra maneira de criar um mosaico de imagem no WPF é usar um System.Windows.Controls.WrapPanel controle e adicionar imagens a ele. O WrapPanel trata do trabalho de posicionamento dos blocos. No entanto, esse trabalho só pode ser executado na linha de execução da interface do usuário.

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;
        }
    }
}

Para criar o exemplo, crie um projeto de aplicativo WPF no Visual Studio e nomeie-o WPF_CS1 (para um projeto do WPF em C#) ou WPF_VB1 (para um projeto do WPF do Visual Basic). Em seguida, faça o seguinte:

1. No modo de exibição de design, arraste um controle Image da Caixa de Ferramentas para o canto superior esquerdo da superfície de design. Na caixa de texto Nome da janela Propriedades , nomeie o controle como "imagem".

2. Arraste um Button controle da Caixa de Ferramentas para a parte inferior esquerda da janela do aplicativo. No modo de exibição XAML, especifique a Content propriedade do botão como "Criar um mosaico" e especifique sua Width propriedade como "100". Conecte o Click evento com o button_Click manipulador de eventos definido no código do exemplo adicionando Click="button_Click" ao <Button> elemento. Na caixa de texto Nome da janela Propriedades , nomeie o controle como "botão".

3. Substitua todo o conteúdo do arquivo MainWindow.xaml.cs ou MainWindow.xaml.vb pelo código deste exemplo. Para um projeto do WPF em C#, verifique se o nome do workspace corresponde ao nome do projeto.

4. O exemplo lê imagens JPEG de um diretório chamado C:\Users\Public\Pictures\Sample Pictures. Crie o diretório e coloque algumas imagens nele ou altere o caminho para se referir a algum outro diretório que contenha imagens.

Este exemplo tem algumas limitações. Por exemplo, há suporte para apenas imagens de 32 bits por pixel; as imagens em outros formatos são corrompidas pelo BitmapImage objeto durante a operação de redimensionamento. Além disso, é necessário que as imagens de origem sejam todas maiores que o tamanho do bloco. Como um exercício adicional, você pode adicionar funcionalidade para lidar com vários formatos de pixel e tamanhos de arquivo.

Acesso thread-safe

Todos os membros do tipo abstrato TaskScheduler são thread-safe e podem ser usados de vários threads simultaneamente.

Confira também

• TaskScheduler
• Biblioteca de tarefas paralelas (TPL)