Passo a passo: Removendo o trabalho de um thread User-Interface

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

Remover o trabalho da interface do utilizador ao transferir operações que bloqueiam, como o desenho, para threads auxiliares pode melhorar a capacidade de resposta do seu aplicativo. Este passo a passo usa uma rotina de desenho que gera o fractal de Mandelbrot para demonstrar uma longa operação de bloqueio. A geração do fractal de 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 seguintes tópicos antes de começar este passo a passo:

Também recomendamos que você entenda os conceitos básicos do desenvolvimento de aplicativos MFC e GDI+ antes de iniciar este passo a passo. Para obter mais informações sobre MFC, consulte Aplicativos de área de trabalho MFC. Para obter mais informações sobre GDI+, consulte GDI+.

Secções

Este passo a passo contém as seguintes seções:

Criando o aplicativo MFC
Implementando a versão serial do aplicativo Mandelbrot
Removendo o trabalho do thread User-Interface
Melhorar o desempenho do desenho
Adicionando suporte para cancelamento

Criando o aplicativo MFC

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

Para criar um aplicativo MFC do Visual C++

Use o MFC Application Wizard para criar um aplicativo MFC com todas as configurações padrão. Consulte Passo a passo: Usando os novos controles de shell MFC para obter instruções sobre como abrir o assistente para sua versão do Visual Studio.
Digite um nome para o projeto, por exemplo, e, em seguida, Mandelbrotclique em OK para exibir o Assistente de aplicativo MFC.
No painel Tipo de Aplicativo , selecione Documento único. Verifique se a caixa de seleção Suporte à arquitetura de documento/exibiçã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-o e executando-o. Para criar o aplicativo, no menu Compilar , clique em Compilar Solução. Se o aplicativo for compilado com êxito, execute o aplicativo clicando em Iniciar Depuração no menu Depurar .

Implementando a versão serial do aplicativo Mandelbrot

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

Para implementar a versão serial do aplicativo Mandelbrot

Em pch.h (stdafx.h no Visual Studio 2017 e anteriores), adicione a seguinte #include diretiva:
```
#include <memory>
```
Em ChildView.h, após a pragma diretiva, defina o BitmapPtr tipo. O BitmapPtr tipo permite que um ponteiro para um Bitmap objeto seja compartilhado por vários componentes. O Bitmap objeto é excluído quando não é mais referenciado por nenhum componente.
```
typedef std::shared_ptr<Gdiplus::Bitmap> BitmapPtr;
```

Em ChildView.h, adicione o seguinte código à protected seção da CChildView classe:

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

protected:
   ULONG_PTR m_gdiplusToken;

Em ChildView.cpp, comente ou remova as seguintes linhas.
```
//#ifdef _DEBUG
//#define new DEBUG_NEW
//#endif
```
Em compilações de depuração, essa etapa impede que o aplicativo use o alocador DEBUG_NEW, que é incompatível com o GDI+.
No ChildView.cpp, adicione uma using diretiva ao Gdiplus namespace.
```
using namespace Gdiplus;
```

Adicione o seguinte código ao construtor e destruidor da classe CChildView para inicializar e encerrar o 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 de Mandelbrot para o objeto especificado Bitmap .

// 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, em seguida, copia o Bitmap conteúdo do objeto para a 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-o e executando-o.

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

A Aplicação Mandelbrot.

Como a computação para cada pixel é computacionalmente cara, o thread da interface do usuário não pode processar mensagens adicionais até que o cálculo geral termine. Isso pode diminuir a capacidade de resposta no aplicativo. No entanto, pode mitigar este problema removendo trabalho do thread da interface de utilizador.

[Topo]

Removendo o trabalho do thread da interface do usuário

Esta secção mostra como remover o trabalho de desenho do thread da interface de utilizador no aplicativo Mandelbrot. Ao mover o trabalho de desenho do thread da UI para um thread de trabalho, o thread da UI pode processar mensagens enquanto o thread de trabalho gera a imagem em segundo plano.

O Concurrency Runtime 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 da interface do usuário, este exemplo usa um objeto concurrency::task_group porque os grupos de tarefas oferecem suporte ao cancelamento. Este passo a passo usa posteriormente o cancelamento para reduzir a quantidade de trabalho que é executado quando a janela do cliente é redimensionada e para executar a limpeza quando a janela é destruída.

Este exemplo também usa um objeto concurrency::unbounded_buffer para permitir que o thread da interface do usuário e o thread de trabalho se comuniquem entre si. Depois do thread de trabalho produzir a imagem, ele envia um ponteiro para o objeto Bitmap e para o objeto unbounded_buffer, e em seguida, publica uma mensagem de renderização para o thread da interface do utilizador. Em seguida, o subprocesso da interface do utilizador recebe o objeto unbounded_buffer a partir do objeto Bitmap e desenha-o na janela do cliente.

Para remover o trabalho de desenho da linha de execução da interface de utilizador

Em pch.h (stdafx.h no Visual Studio 2017 e anteriores), adicione as seguintes #include diretivas:
```
#include <agents.h>
#include <ppl.h>
```
Em ChildView.h, adicione as variáveis membro task_group e unbounded_buffer à seção protected da classe CChildView. O task_group objeto contém as tarefas que executam o desenho, o unbounded_buffer objeto contém a imagem de Mandelbrot concluída.
```
concurrency::task_group m_DrawingTasks;
concurrency::unbounded_buffer<BitmapPtr> m_MandelbrotImages;
```
No ChildView.cpp, adicione uma using diretiva ao concurrency namespace.
```
using namespace concurrency;
```
Após a chamada para CChildView::DrawMandelbrot no método Bitmap::UnlockBits, chame a função concurrency::send para passar o objeto Bitmap para a thread da interface do utilizador. Em seguida, publique uma mensagem de pintura no thread da interface do usuário e invalide 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);
```

Atualize o CChildView::OnPaint método para receber o objeto atualizado Bitmap e desenhe 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 mensagens. O buffer de mensagens não conterá um Bitmap objeto em casos como a mensagem de pintura inicial e quando outra janela for movida na frente da janela do cliente.

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

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

[Topo]

Melhorar o desempenho do desenho

A geração do fractal de Mandelbrot é um bom candidato para paralelização porque a computação de cada pixel é independente de todos os outros cálculos. Para paralelizar o procedimento de desenho, converta o loop externo for no método CChildView::DrawMandelbrot em uma chamada para o algoritmo concurrency::parallel_for, da seguinte maneira.

// 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, não é necessário sincronizar as operações de desenho que acessam a memória de bitmap. Isso permite que o desempenho seja dimensionado à medida que o número de processadores disponíveis aumenta.

[Topo]

Adicionando suporte para cancelamento

Esta seção descreve como lidar com o redimensionamento de janelas e como cancelar quaisquer tarefas de desenho ativas quando a janela é destruída.

O documento Cancelamento no PPL explica como funciona o cancelamento em tempo de execução. O cancelamento é cooperativo; portanto, não ocorre imediatamente. Para interromper uma tarefa cancelada, o runtime lança uma exceção interna durante uma chamada subsequente da tarefa para o runtime. 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 runtime interrompa a tarefa e, assim, que o cancelamento funcione.

Cancelando tarefas ativas

O aplicativo Mandelbrot cria Bitmap objetos cujas dimensões correspondem ao tamanho da janela do cliente. Toda vez que a janela do cliente é redimensionada, o aplicativo cria uma tarefa de plano de fundo adicional para gerar uma imagem para o novo tamanho da janela. O aplicativo não requer essas imagens intermediárias; requer apenas a imagem para o tamanho final da janela. Para impedir que o aplicativo execute esse trabalho adicional, você pode cancelar todas as tarefas de desenho ativas nos manipuladores de mensagens para as WM_SIZE mensagens e WM_SIZING e, em seguida, reagendar o trabalho de desenho depois que a janela for redimensionada.

Para cancelar tarefas de desenho ativas quando a janela é redimensionada, o aplicativo chama o método concurrency::task_group::cancel nos manipuladores das mensagens WM_SIZING e WM_SIZE. O manipulador da WM_SIZE mensagem também chama o método concurrency::task_group::wait para aguardar a conclusão de todas as tarefas ativas e, em seguida, reagenda a tarefa de desenho para o tamanho da janela atualizado.

Quando a janela do cliente é destruída, é uma boa prática cancelar todas as tarefas de desenho ativas. O cancelamento de quaisquer tarefas de desenho ativas garante que os threads de trabalho não postem mensagens no thread da interface do usuário depois que a janela do cliente for destruída. A aplicação cancela todas as tarefas de desenho ativas no manipulador da WM_DESTROY mensagem.

Respondendo ao cancelamento

O CChildView::DrawMandelbrot método, que executa a tarefa de desenho, deve responder ao cancelamento. Como o tempo de execução usa o tratamento de exceções para cancelar tarefas, o CChildView::DrawMandelbrot método deve usar um mecanismo seguro contra exceções para garantir que todos os recursos sejam limpos corretamente. Este exemplo usa o padrão RAII (Resource Acquisition Is Initialization ) para garantir que os bits de bitmap sejam desbloqueados quando a tarefa for cancelada.

Para adicionar suporte para cancelamento no aplicativo Mandelbrot

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

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 de mensagens para conter manipuladores para as mensagens WM_SIZE, WM_SIZING e WM_DESTROY.

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 todas as 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. Esse método cancela todas as tarefas de desenho existentes e cria uma nova tarefa de desenho para o tamanho atualizado da janela do cliente.

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 todas as 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 a 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 ao 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 lida com o cancelamento criando um scope_guard objeto. Quando o objeto sai do escopo, ele desbloqueia os bits de bitmap.

Modifique o final do CChildView::DrawMandelbrot método para descartar o scope_guard objeto depois que os bits de bitmap forem desbloqueados, mas antes de enviar qualquer mensagem para o thread da interface gráfica. Isso garante que o thread da interface do usuário não seja atualizado antes que os bits de bitmap sejam 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-o e executando-o.

Quando você redimensiona a janela, o trabalho de desenho é executado apenas para o tamanho final da janela. Todas as tarefas de desenho ativas também são canceladas quando a janela é destruída.

[Topo]

Ver também

Passo a passo do Concurrency Runtime
Paralelismo de tarefas
Blocos de mensagens assíncronas
Funções de passagem de mensagens
Algoritmos paralelos
Cancelamento no PPL
Aplicações de ambiente de trabalho MFC

Feedback

Esta página foi útil?

Last updated on 2025-11-07

Partilhar via

Passo a passo: Removendo o trabalho de um thread User-Interface

Pré-requisitos

Secções

Criando o aplicativo MFC

Para criar um aplicativo MFC do Visual C++

Implementando a versão serial do aplicativo Mandelbrot

Para implementar a versão serial do aplicativo Mandelbrot

Removendo o trabalho do thread da interface do usuário

Para remover o trabalho de desenho da linha de execução da interface de utilizador

Melhorar o desempenho do desenho

Adicionando suporte para cancelamento

Cancelando tarefas ativas

Respondendo ao cancelamento

Para adicionar suporte para cancelamento no aplicativo Mandelbrot

Ver também

Feedback

Recursos adicionais