Passo a passo: Removendo o trabalho de um encadeamento de interface do usuário

Artigo
02/25/2013

Este documento demonstra como usar o Runtime de simultaneidade para mover o trabalho realizado pelo segmento de interface do usuário (UI) em um aplicativo Microsoft Foundation Classes (MFC) para o thread de trabalho.Este documento demonstra também como melhorar o desempenho de uma operação demorada de desenho.

Removendo o trabalho do thread da interface do usuário reduzindo o bloqueio de operações, por exemplo, desenho para threads de trabalho pode melhorar a resposta do seu aplicativo.Esta explicação passo a passo usa uma rotina de desenho que gera o fractal Mandelbrot para demonstrar uma longa operação de bloqueio.A geração de fractal Mandelbrot também é um bom candidato para paralelização porque a computação de cada pixel é independente de todos os outros cálculos.

Pré-requisitos

Leia os tópicos a seguir antes de iniciar esta explicação passo a passo:

Também recomendamos que você entenda os fundamentos do desenvolvimento de aplicativos MFC e GDI+ antes de iniciar esta explicação passo a passo.Para obter mais informações sobre o MFC, consulte Aplicativos para desktop do MFC.Para obter mais informações sobre GDI+, consulte GDI+.

Seções

Esta explicação passo a passo contém as seções a seguir:

Criando o aplicativo do MFC
Implementando a versão Serial do aplicativo Mandelbrot
Removendo o trabalho do Thread de Interface do usuário
Melhorando o desempenho do desenho
Adicionando suporte a cancelamento

Criando o aplicativo do MFC

Esta seção descreve como criar o aplicativo básico do MFC.

Para criar um aplicativo do Visual C++ MFC

No menu File, clique em New, e em seguida, clique em Project
No Novo projeto na caixa de Modelos instalados painel, selecione **Visual C++**e, em seguida, no modelos painel, selecione Aplicativo MFC.Digite um nome para o projeto, por exemplo, Mandelbrote clique em OK para exibir o MFC Application Wizard.
No Tipo de aplicativo , selecione documento único.Garantir que o suporte a arquitetura de exibição do documento caixa de seleção está desmarcada.
Clique em Concluir para criar o projeto e fechar o MFC Application Wizard.

Verifique se o aplicativo foi criado com êxito, criando e executando-o.Para criar o aplicativo, no Build menu, clique em Build Solution.Se o aplicativo foi criado com êxito, execute o aplicativo clicando em Start Debugging sobre o Debug menu.

Implementando a versão Serial do aplicativo Mandelbrot

Esta seção descreve como desenhar o fractal de Mandelbrot.Esta versão desenha o fractal Mandelbrot para um GDI+Bitmap object e copia o conteúdo desse bitmap para a janela do cliente.

Para implementar a versão serial do aplicativo Mandelbrot

Em stdafx. h, adicione o seguinte #include diretiva:
```
#include <memory>
```
No ChildView.h, após o pragma diretiva, defina o BitmapPtr tipo.O BitmapPtr tipo permite que um ponteiro para um Bitmap o objeto a ser compartilhado por vários componentes.O Bitmap objeto é excluído quando ele não é referenciado por qualquer componente.
```
typedef std::shared_ptr<Gdiplus::Bitmap> BitmapPtr;
```

No ChildView.h, adicione o seguinte código para o protected seção de CChildView classe:

protected:
   // Draws the Mandelbrot fractal to the specified Bitmap object.
   void DrawMandelbrot(BitmapPtr);

protected:
   ULONG_PTR m_gdiplusToken;

Na ChildView.cpp, comente ou remova as seguintes linhas.
```
//#ifdef _DEBUG
//#define new DEBUG_NEW
//#endif
```
Em compilações de depuração, esta etapa impede que o aplicativo usando o DEBUG_NEW alocador, que é incompatível com GDI+.
ChildView.cpp, adicione um using diretriz para o Gdiplus namespace.
```
using namespace Gdiplus;
```

Adicione o seguinte código ao construtor e destruidor do CChildView classe para inicializar e desligar GDI+.

CChildView::CChildView()
{
   // Initialize GDI+.
   GdiplusStartupInput gdiplusStartupInput;
   GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL);
}

CChildView::~CChildView()
{
   // Shutdown GDI+.
   GdiplusShutdown(m_gdiplusToken);
}

Implemente o método CChildView::DrawMandelbrot.Este método desenha o fractal Mandelbrot para o Bitmap objeto.

// Draws the Mandelbrot fractal to the specified Bitmap object.
void CChildView::DrawMandelbrot(BitmapPtr pBitmap)
{
   if (pBitmap == NULL)
      return;

   // Get the size of the bitmap.
   const UINT width = pBitmap->GetWidth();
   const UINT height = pBitmap->GetHeight();

   // Return if either width or height is zero.
   if (width == 0 || height == 0)
      return;

   // Lock the bitmap into system memory.
   BitmapData bitmapData;   
   Rect rectBmp(0, 0, width, height);
   pBitmap->LockBits(&rectBmp, ImageLockModeWrite, PixelFormat32bppRGB, 
      &bitmapData);

   // Obtain a pointer to the bitmap bits.
   int* bits = reinterpret_cast<int*>(bitmapData.Scan0);

   // Real and imaginary bounds of the complex plane.
   double re_min = -2.1;
   double re_max = 1.0;
   double im_min = -1.3;
   double im_max = 1.3;

   // Factors for mapping from image coordinates to coordinates on the complex plane.
   double re_factor = (re_max - re_min) / (width - 1);
   double im_factor = (im_max - im_min) / (height - 1);

   // The maximum number of iterations to perform on each point.
   const UINT max_iterations = 1000;

   // Compute whether each point lies in the Mandelbrot set.
   for (UINT row = 0u; row < height; ++row)
   {
      // Obtain a pointer to the bitmap bits for the current row.
      int *destPixel = bits + (row * width);

      // Convert from image coordinate to coordinate on the complex plane.
      double y0 = im_max - (row * im_factor);

      for (UINT col = 0u; col < width; ++col)
      {
         // Convert from image coordinate to coordinate on the complex plane.
         double x0 = re_min + col * re_factor;

         double x = x0;
         double y = y0;

         UINT iter = 0;
         double x_sq, y_sq;
         while (iter < max_iterations && ((x_sq = x*x) + (y_sq = y*y) < 4))
         {
            double temp = x_sq - y_sq + x0;
            y = 2 * x * y + y0;
            x = temp;
            ++iter;
         }

         // If the point is in the set (or approximately close to it), color
         // the pixel black.
         if(iter == max_iterations) 
         {         
            *destPixel = 0;
         }
         // Otherwise, select a color that is based on the current iteration.
         else
         {
            BYTE red = static_cast<BYTE>((iter % 64) * 4);
            *destPixel = red<<16;
         }

         // Move to the next point.
         ++destPixel;
      }
   }

   // Unlock the bitmap from system memory.
   pBitmap->UnlockBits(&bitmapData);
}

Implemente o método CChildView::OnPaint.Este método chama CChildView::DrawMandelbrot e copia o conteúdo do Bitmap o objeto na janela.

void CChildView::OnPaint() 
{
   CPaintDC dc(this); // device context for painting

   // Get the size of the client area of the window.
   RECT rc;
   GetClientRect(&rc);

   // Create a Bitmap object that has the width and height of 
   // the client area.
   BitmapPtr pBitmap(new Bitmap(rc.right, rc.bottom));

   if (pBitmap != NULL)
   {
      // Draw the Mandelbrot fractal to the bitmap.
      DrawMandelbrot(pBitmap);

      // Draw the bitmap to the client area.
      Graphics g(dc);
      g.DrawImage(pBitmap.get(), 0, 0);
   }
}

Verifique se o aplicativo foi atualizado com êxito, criando e executando-o.

A ilustração a seguir mostra os resultados do aplicativo Mandelbrot.

O aplicativo de Mandelbrot

Como a computação para cada pixel é dispendiosa, o segmento de interface do usuário não pode processar mensagens adicionais até que termine a computação geral.Isso pode diminuir a capacidade de resposta do aplicativo.No entanto, você pode aliviar esse problema removendo o trabalho do thread de interface do usuário.

Top

Removendo o trabalho de segmento de interface do usuário

Esta seção mostra como remover o trabalho de desenho do thread da interface do usuário no aplicativo de Mandelbrot.Movendo trabalho desenho do thread de interface do usuário para um segmento de trabalho, o segmento de interface do usuário pode processar as mensagens como o thread de trabalho gera a imagem no plano de fundo.

O Runtime de simultaneidade fornece três maneiras de executar tarefas: grupos de tarefas, agentes assíncronos, e tarefas leves.Embora você possa usar qualquer um desses mecanismos para remover o trabalho do thread de interface do usuário, este exemplo usa um concurrency::task_group porque os grupos de tarefas oferece suporte ao cancelamento.Esta explicação passo a passo usa posterior cancelamento para reduzir a quantidade de trabalho é executada quando o cliente for redimensionada e executar limpeza quando a janela é destruída.

Este exemplo também usa um concurrency::unbounded_buffer objeto para permitir que o thread de interface do usuário e o segmento de trabalho para se comunicar uns com os outros.Depois que o thread de trabalho produz a imagem, ele envia um ponteiro para o Bitmap o objeto para o unbounded_buffer objeto e, em seguida, envia uma mensagem de pintura para o segmento de interface do usuário.O segmento de interface do usuário recebe depois do unbounded_buffer objeto do Bitmap object e desenha a janela do cliente.

Para remover o trabalho de desenho do thread de interface do usuário

Em stdafx. h, adicione o seguinte #include diretivas:
```
#include <agents.h>
#include <ppl.h>
```
ChildView.h, adicione task_group e unbounded_buffer variáveis de membro para o protected seção de CChildView classe.O task_group objeto contém as tarefas que executar o desenho; o unbounded_buffer objeto contém a imagem completa de Mandelbrot.
```
concurrency::task_group m_DrawingTasks;
concurrency::unbounded_buffer<BitmapPtr> m_MandelbrotImages;
```
ChildView.cpp, adicione um using diretriz para o concurrency namespace.
```
using namespace concurrency;
```
No CChildView::DrawMandelbrot método, após a chamada para Bitmap::UnlockBits, chamar o concurrency::send função passar o Bitmap objeto para o segmento de interface do usuário.Em seguida, postar uma mensagem de pintura para o segmento de interface do usuário e invalidar a área do cliente.
```
// Unlock the bitmap from system memory.
pBitmap->UnlockBits(&bitmapData);

// Add the Bitmap object to image queue.
send(m_MandelbrotImages, pBitmap);

// Post a paint message to the UI thread.
PostMessage(WM_PAINT);
// Invalidate the client area.
InvalidateRect(NULL, FALSE);
```

Atualização do CChildView::OnPaint método para receber o atualizado Bitmap object e desenhar a imagem na janela do cliente.

void CChildView::OnPaint() 
{
   CPaintDC dc(this); // device context for painting

   // If the unbounded_buffer object contains a Bitmap object, 
   // draw the image to the client area.
   BitmapPtr pBitmap;
   if (try_receive(m_MandelbrotImages, pBitmap))
   {
      if (pBitmap != NULL)
      {
         // Draw the bitmap to the client area.
         Graphics g(dc);
         g.DrawImage(pBitmap.get(), 0, 0);
      }
   }
   // Draw the image on a worker thread if the image is not available.
   else
   {
      RECT rc;
      GetClientRect(&rc);
      m_DrawingTasks.run([rc,this]() {
         DrawMandelbrot(BitmapPtr(new Bitmap(rc.right, rc.bottom)));
      });
   }
}

O CChildView::OnPaint método cria uma tarefa para gerar a imagem de Mandelbrot se não existir no buffer de mensagem.O buffer de mensagem não conterá um Bitmap objeto em casos como, por exemplo, a mensagem inicial de pintura e outra janela é movida na frente da janela do cliente.

Verifique se o aplicativo foi atualizado com êxito, criando e executando-o.

A interface do usuário agora é mais responsiva porque o trabalho de desenho é executado em segundo plano.

Top

Melhorando o desempenho do desenho

A geração de fractal Mandelbrot é um bom candidato para paralelização porque a computação de cada pixel é independente de todos os outros cálculos.Em paralelo o procedimento de desenho, converter o externo for loop no CChildView::DrawMandelbrot método para uma chamada para o concurrency::parallel_for algoritmo, como segue.

// Compute whether each point lies in the Mandelbrot set.
parallel_for (0u, height, [&](UINT row)
{
   // Loop body omitted for brevity.
});

Como o cálculo de cada elemento de bitmap é independente, é necessário que sincronizar as operações de desenho acessam à memória do bitmap.Isso permite que o desempenho dimensionado como o aumento do número de processadores disponíveis.

Top

Adicionando suporte a cancelamento

Esta seção descreve como manipular o redimensionamento de janela e Cancelar quaisquer tarefas de desenho ativas quando a janela é destruída.

O documento Cancelar o PPL explica como funciona o cancelamento no tempo de execução.Cancelamento é cooperativo; Portanto, não ocorre imediatamente.Para interromper uma tarefa cancelada, o tempo de execução lança uma exceção interna durante uma chamada subseqüente da tarefa no tempo de execução.A seção anterior mostra como usar o parallel_for algoritmo para melhorar o desempenho da tarefa de desenho.A chamada para parallel_for permite que o tempo de execução interromper a tarefa e, portanto, permite o cancelamento funcione.

Cancelando tarefas ativas

Cria o aplicativo Mandelbrot Bitmap objetos cujas dimensões corresponder ao tamanho da janela do cliente.Sempre que a janela do cliente é redimensionada, o aplicativo cria uma tarefa de plano de fundo adicional para gerar uma imagem para o novo tamanho de janela.O aplicativo não exigir essas imagens intermediárias; ela exige apenas a imagem para o tamanho da janela final.Para impedir que o aplicativo executando esse trabalho adicional, você pode cancelar quaisquer tarefas de desenho ativas nos manipuladores de mensagem para o WM_SIZE e WM_SIZING mensagens e, em seguida, desenho de reagendar trabalham depois que a janela é redimensionada.

Cancelar tarefas ativas de desenho quando a janela é redimensionada, o aplicativo chama o concurrency::task_group::cancel método em manipuladores para os WM_SIZING e WM_SIZE mensagens.O manipulador para o WM_SIZE mensagem também chamadas a concurrency::task_group::wait método espera para ativo todas as tarefas para concluir e então reagenda a tarefa de desenho para o tamanho da janela atualizado.

Quando a janela do cliente é destruída, é recomendável cancelar quaisquer tarefas de desenho ativas.Cancelar tarefas desenho ativas certifica que threads de trabalho não postar mensagens para o segmento de interface do usuário depois que a janela do cliente é destruída.O aplicativo Cancela quaisquer tarefas de desenho ativas no manipulador para o WM_DESTROY mensagem.

Responder ao cancelamento

O CChildView::DrawMandelbrot método, que executa a tarefa de desenho, deve responder ao cancelamento.Porque o tempo de execução usa o tratamento de exceção para cancelar as tarefas, o CChildView::DrawMandelbrot método deve usar um mecanismo de exceção segura para garantir que todos os recursos estão corretamente limpos-up.Este exemplo usa o Recurso de aquisição é inicialização padrão (RAII) para garantir que os bits de bitmap são desbloqueados quando a tarefa é cancelada.

Para adicionar suporte para o cancelamento do aplicativo de Mandelbrot

Em ChildView.h, no protected seção a CChildView classe, adicione declarações para o OnSize, OnSizing, e OnDestroy funções de mapa da mensagem.

afx_msg void OnPaint();
afx_msg void OnSize(UINT, int, int);
afx_msg void OnSizing(UINT, LPRECT); 
afx_msg void OnDestroy();
DECLARE_MESSAGE_MAP()

No ChildView.cpp, modifique o mapa da mensagem contém manipuladores de WM_SIZE, WM_SIZING, e WM_DESTROY mensagens.

BEGIN_MESSAGE_MAP(CChildView, CWnd)
   ON_WM_PAINT()
   ON_WM_SIZE()
   ON_WM_SIZING()
   ON_WM_DESTROY()
END_MESSAGE_MAP()

Implemente o método CChildView::OnSizing.Este método cancela quaisquer tarefas de desenho existentes.

void CChildView::OnSizing(UINT nSide, LPRECT lpRect)
{
   // The window size is changing; cancel any existing drawing tasks.
   m_DrawingTasks.cancel();
}

Implemente o método CChildView::OnSize.Este método cancela quaisquer tarefas de desenho existentes e cria uma nova tarefa de desenho para o tamanho da janela cliente atualizado.

void CChildView::OnSize(UINT nType, int cx, int cy)
{
   // The window size has changed; cancel any existing drawing tasks.
   m_DrawingTasks.cancel();
   // Wait for any existing tasks to finish.
   m_DrawingTasks.wait();

   // If the new size is non-zero, create a task to draw the Mandelbrot 
   // image on a separate thread.
   if (cx != 0 && cy != 0)
   {      
      m_DrawingTasks.run([cx,cy,this]() {
         DrawMandelbrot(BitmapPtr(new Bitmap(cx, cy)));
      });
   }
}

Implemente o método CChildView::OnDestroy.Este método cancela quaisquer tarefas de desenho existentes.

void CChildView::OnDestroy()
{
   // The window is being destroyed; cancel any existing drawing tasks.
   m_DrawingTasks.cancel();
   // Wait for any existing tasks to finish.
   m_DrawingTasks.wait();
}

Em ChildView.cpp, defina o scope_guard classe, que implementa o padrão RAII.

// Implements the Resource Acquisition Is Initialization (RAII) pattern 
// by calling the specified function after leaving scope.
class scope_guard 
{
public:
   explicit scope_guard(std::function<void()> f)
      : m_f(std::move(f)) { }

   // Dismisses the action.
   void dismiss() {
      m_f = nullptr;
   }

   ~scope_guard() {
      // Call the function.
      if (m_f) {
         try {
            m_f();
         }
         catch (...) {
            terminate();
         }
      }
   }

private:
   // The function to call when leaving scope.
   std::function<void()> m_f;

   // Hide copy constructor and assignment operator.
   scope_guard(const scope_guard&);
   scope_guard& operator=(const scope_guard&);
};

Adicione o seguinte código para o CChildView::DrawMandelbrot método após a chamada para Bitmap::LockBits:

// Create a scope_guard object that unlocks the bitmap bits when it
// leaves scope. This ensures that the bitmap is properly handled
// when the task is canceled.
scope_guard guard([&pBitmap, &bitmapData] {
   // Unlock the bitmap from system memory.
   pBitmap->UnlockBits(&bitmapData);      
});

Esse código manipula o cancelamento, criando um scope_guard objeto.Quando o objeto sai do escopo, ele desbloqueia os bits de bitmap.

Modificar o fim do CChildView::DrawMandelbrot método para descartar a scope_guard objeto após os bits de bitmap são desbloqueados, mas antes de todas as mensagens são enviadas para o segmento de interface do usuário.Isso garante que o segmento de interface do usuário não é atualizado antes que os bits de bitmap são desbloqueados.

// Unlock the bitmap from system memory.
pBitmap->UnlockBits(&bitmapData);

// Dismiss the scope guard because the bitmap has been 
// properly unlocked.
guard.dismiss();

// Add the Bitmap object to image queue.
send(m_MandelbrotImages, pBitmap);

// Post a paint message to the UI thread.
PostMessage(WM_PAINT);
// Invalidate the client area.
InvalidateRect(NULL, FALSE);

Verifique se o aplicativo foi atualizado com êxito, criando e executando-o.

Quando você redimensiona a janela, trabalho de desenho é realizada somente para o tamanho da janela final.As tarefas de desenho ativas também serão canceladas quando a janela é destruída.

Top