Instruções passo a passo: removendo trabalho de um thread de interface de usuário

Artigo
06/16/2023

Este documento demonstra como usar o Runtime de Simultaneidade para mover o trabalho executado pelo thread de interface do usuário em um aplicativo da MFC para um thread de trabalho. Este documento também demonstra como aprimorar o desempenho de uma longa operação de desenho.

Remover o trabalho do thread da IU ao descarregar operações de bloqueio (por exemplo, desenho) para threads de trabalho pode aprimorar a capacidade de resposta do aplicativo. Este passo a passo usa uma rotina de desenho que gera o fractal Mandelbrot para demonstrar uma longa operação de bloqueio. A geração do fractal Mandelbrot também é uma boa candidata para paralelização porque a computação de cada pixel é independente de todas as outras computações.

Pré-requisitos

Leia os seguintes tópicos antes de iniciar este passo a passo:

Também recomendamos que você entenda as noções básicas do desenvolvimento de aplicativos da MFD e do GDI+ antes de iniciar este passo a passo. Para obter mais informações, confira Aplicativos de área de trabalho da MFC. Para obter mais informações sobre GDI+, confira GDI+.

Seções

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

Criar um aplicativo da MFC
Implementar a versão serial do aplicativo Mandelbrot
Remover trabalho de um thread da interface de usuário
Aprimorar o desempenho do desenho
Adicionar suporte ao cancelamento

Criar um aplicativo da MFC

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

Criar um aplicativo da MFC no Visual C++

Use o Assistente para Aplicativo do MFC para criar um aplicativo MFC com todas as configurações padrão. Confira Guia passo a passo: usar os novos controles de shell do MFC para instruções sobre como abrir o assistente em sua versão do Visual Studio.
Digite um nome para o projeto, por exemplo, Mandelbrot, e clique em OK para exibir o Assistente de Aplicativo da 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 Assistente de Aplicativo da MFC.

Verifique se o aplicativo foi criado com êxito compilando e executando-o. Para compilar o aplicativo, no menu Compilar, clique em Compilar Solução. Se o aplicativo for compilado com êxito, execute-o clicando em Iniciar Depuração no menu Depurar.

Implementar a versão serial do aplicativo Mandelbrot

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

Implementar a versão serial do aplicativo Mandelbrot

Em pch.h (stdafx.h no Visual Studio 2017 e anteriores), adicione a seguinte diretiva #include:
```
#include <memory>
```
Em ChildView.h, após a diretiva pragma, defina o tipo BitmapPtr. O tipo BitmapPtr permite que um ponteiro para um objeto Bitmap seja compartilhado por vários componentes. O objeto Bitmap é 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 à seção protected da classe CChildView:

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 linhas a seguir.
```
//#ifdef _DEBUG
//#define new DEBUG_NEW
//#endif
```
Em builds de depuração, essa etapa impede que o aplicativo use o alocador DEBUG_NEW, que é incompatível com GDI+.
Em ChildView.cpp, adicione uma diretiva using ao namespace Gdiplus.
```
using namespace Gdiplus;
```

Adicione o código a seguir ao construtor e ao destruidor da classe CChildView para inicializar e desligar o GDI+.

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

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

Implementar o método de CChildView::DrawMandelbrot . Esse método desenha o fractal Mandelbrot para o objeto Bitmap especificado.

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

Implementar o método de CChildView::OnPaint . Esse método chama CChildView::DrawMandelbrot e copia o conteúdo do objeto Bitmap 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 compilando e executando-o.

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

The Mandelbrot Application.

Como a computação para cada pixel é computacionalmente cara, o thread da IU não pode processar mensagens adicionais até que a computação geral seja concluída. Isso pode diminuir a capacidade de resposta no aplicativo. No entanto, você pode aliviar esse problema removendo o trabalho do thread da IU.

[Parte superior]

Remover o trabalho do thread da IU

Esta seção mostra como remover o trabalho de desenho do thread da IU no aplicativo Mandelbrot. Ao mover o trabalho de desenho do thread da IU para um thread de trabalho, o thread da IU poderá processar mensagens à medida que o thread de trabalho gera a imagem em segundo plano.

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 da IU, este exemplo usa um objeto concurrency::task_group porque os grupos de tarefas dão suporte ao cancelamento. Este passo a passo usa o cancelamento posteriormente para reduzir a quantidade de trabalho que é executada 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 habilitar o thread da IU e o thread de trabalho a se comunicarem. Depois que o thread de trabalho produz a imagem, ele envia um ponteiro para o objeto Bitmap e para o objeto unbounded_buffer e, em seguida, posta uma mensagem de pintura no thread da IU. O thread da IU recebe do objeto unbounded_buffer o objeto Bitmap e o desenha para a janela do cliente.

Remover o trabalho de desenho do thread da IU

Em pch.h (stdafx.h no Visual Studio 2017 e anteriores), adicione as seguintes diretivas #include:
```
#include <agents.h>
#include <ppl.h>
```
Em ChildView.h, adicione as variáveis de membro task_group e unbounded_buffer à seção protected da classe CChildView. O objeto task_group contém as tarefas que executam o desenho. O objeto unbounded_buffer contém a imagem Mandelbrot concluída.
```
concurrency::task_group m_DrawingTasks;
concurrency::unbounded_buffer<BitmapPtr> m_MandelbrotImages;
```
Em ChildView.cpp, adicione uma diretiva using ao namespace concurrency.
```
using namespace concurrency;
```

No método CChildView::DrawMandelbrot, após a chamada a Bitmap::UnlockBits, chame a função concurrency::send para passar o objeto Bitmap para o thread da IU. Em seguida, poste uma mensagem de pintura no thread da IU e invalide a área de 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 método CChildView::OnPaint para receber o objeto Bitmap atualizado 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 método CChildView::OnPaint cria uma tarefa para gerar a imagem Mandelbrot se não existir uma no buffer de mensagens. O buffer de mensagem não conterá um objeto Bitmap 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 compilando e executando-o.

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

[Parte superior]

Aprimorar o desempenho do desenho

A geração do fractal Mandelbrot é uma boa candidata para paralelização porque a computação de cada pixel é independente de todas as outras computações. 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 a computação de cada elemento bitmap é independente, você não precisa sincronizar as operações de desenho que acessam a memória do bitmap. Isso permite que o desempenho seja dimensionado à medida que o número de processadores disponíveis aumenta.

[Parte superior]

Adicionar suporte ao cancelamento

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

O documento Cancelamento no PPL explica como o cancelamento funciona no runtime. O cancelamento é cooperativo, portanto, isso não ocorre imediatamente. Para interromper uma tarefa cancelada, o runtime gera uma exceção interna durante uma chamada subsequente da tarefa no runtime. A seção anterior mostra como usar o algoritmo parallel_for para aprimorar o desempenho da tarefa de desenho. A chamada para parallel_for permite que o runtime interrompa a tarefa e, portanto, permite que o cancelamento funcione.

Cancelar tarefas ativas

O aplicativo Mandelbrot cria objetos Bitmap cujas dimensões correspondem ao tamanho da janela do cliente. Sempre que a janela do cliente é redimensionada, o aplicativo cria uma tarefa em segundo plano adicional para gerar uma imagem para o novo tamanho da janela. O aplicativo não requer essas imagens intermediárias. Ele 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 mensagens WM_SIZE 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 para as mensagens WM_SIZING e WM_SIZE. O manipulador da mensagem WM_SIZE 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 atualizada.

Quando a janela do cliente é destruída, é uma boa prática cancelar todas as tarefas de desenho ativas. Cancelar tarefas de desenho ativas garante que os threads de trabalho não postem mensagens no thread da IU depois que a janela do cliente é destruída. O aplicativo cancela todas as tarefas de desenho ativas no manipulador para a mensagem WM_DESTROY.

Responder ao cancelamento

O método CChildView::DrawMandelbrot, que executa a tarefa de desenho, deve responder ao cancelamento. Como o runtime usa tratamento de exceção para cancelar tarefas, o método CChildView::DrawMandelbrot deve usar um mecanismo de segurança de exceção 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 é cancelada.

Adicionar suporte para cancelamento no aplicativo Mandelbrot

Em ChildView.h, na seção protected da classe CChildView, adicione declarações para as funções de 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()

Em 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()

Implementar o método de CChildView::OnSizing . Esse 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();
}

Implementar o método de CChildView::OnSize . Esse método cancela todas as tarefas de desenho existentes e cria uma 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)));
      });
   }
}

Implementar o método de CChildView::OnDestroy . Esse 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 classe scope_guard, 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 método CChildView::DrawMandelbrot 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 objeto scope_guard. Quando o objeto sai do escopo, ele desbloqueia os bits de bitmap.

Modifique o final do método CChildView::DrawMandelbrot para descartar o objeto scope_guard depois que os bits de bitmap forem desbloqueados, mas antes que qualquer mensagem seja enviada para o thread da IU. Isso garante que o thread da IU 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 compilando e executando-o.

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

[Parte superior]

Confira também

Instruções passo a passo do runtime de simultaneidade
Paralelismo de tarefas
Blocos de mensagens assíncronos
Funções de transmissão de mensagem
Algoritmos paralelos
Cancelamento no PPL
Aplicativos da área de trabalho MFC

Instruções passo a passo: removendo trabalho de um thread de interface de usuário

Pré-requisitos

Seções

Criar um aplicativo da MFC

Criar um aplicativo da MFC no Visual C++

Implementar a versão serial do aplicativo Mandelbrot

Implementar a versão serial do aplicativo Mandelbrot

Remover o trabalho do thread da IU

Remover o trabalho de desenho do thread da IU

Aprimorar o desempenho do desenho

Adicionar suporte ao cancelamento

Cancelar tarefas ativas

Responder ao cancelamento

Adicionar suporte para cancelamento no aplicativo Mandelbrot

Confira também

Comentários

Comentários

Recursos adicionais