Como usar o Multithreading em C ++

Multithreading é o conceito de executar vários tópicos de execução em um único programa. É um recurso muito útil em linguagens de programação como C ++, pois nos permite realizar várias operações simultaneamente. Em c++, multithreading pode ser alcançado através do Biblioteca, que fornece um conjunto de classes e funções que permitem aos desenvolvedores criar, gerenciar e controlar vários threads.

Multithreading é como multitarefa. Isso significa que dois ou mais threads estão funcionando simultaneamente. Nesse programa, cada componente é referido como um thread, e cada thread especifica um caminho único de execução. Não há suporte embutido para multithreaded programas antes do C ++ 11. Esse recurso é totalmente fornecido pelo sistema operacional.

Multithreading também pode ser referido como dividir um programa em tópicos menores que executam simultaneamente. A classe de threads, que é usada para multithreading Em C ++, permite construir vários tópicos e gerenciar sua execução.

Crie threads em C++

Para criar um tópico em C ++, usamos o std :: thread classe, que está incluída na biblioteca de threads embutidos. A chamável é fornecido como um argumento ao construtor de um objeto da classe std :: thread Para gerar um novo tópico. Código que é executado quando um thread é ativo é conhecido como chamável. Quando construímos um std :: thread objeto, um novo tópico é estabelecido, o que causa o código fornecido por chamável para ser executado. Chamável pode ser definido usando esses três métodos.

Método 1: Ponteiro de função

Chamável funções usando um ponteiro de função podem ser definidas assim.

void function_call (parâmetros)

Quando a função foi construída, um objeto de encadeamento que contém a função é gerado da seguinte forma:

std :: thread thread_obj (function_call, parâmetros);

Método 2: Objeto de função

Enquanto utiliza o objeto de função, aproveitamos a idéia de sobrecarga do operador. O código que deve ser executado enquanto o segmento está sendo formado está contido na função sobrecarregada.

classe object_class
operador void () (parâmetros)

// código a ser executado

;
std :: thread thread_object (object_class (), parâmetros)

Método 3: expressão lambda

Chamável funções usando uma expressão lambda podem ser definidas assim.

auto f = [] (parâmetros)
// código a ser executado
;
std :: thread thread_object (f, parâmetros);

Exemplo de multithreading em C++

#incluir
#incluir
usando namespace std;
void func_thread (int n)

para (int i = 0; i < N; i++)
cout << "Thread 1 :: callable => Usando um ponteiro de função \ n ";


classe Thread_obj
público:
operador void () (int n)
para (int i = 0; i < n; i++)
cout << "Thread 2 :: callable => Usando um objeto de função \ n ";

;
int main ()

Auto f = [] (int n)
para (int i = 0; i < n; i++)
cout << "Thread 3 :: callable => Usando uma expressão lambda \ n ";
;
Thread Th1 (func_thread, 2);
Thread Th2 (Thread_obj (), 2);
Thread Th3 (F, 2);
Th1.juntar();
Th2.juntar();
Th3.juntar();
retornar 0;

No código acima, desenvolvemos três tópicos com três separados callables-um ponteiro de função, um objeto e uma expressão de lambda. Cada tópico é iniciado como duas instâncias separadas. Três fios são ativos simultaneamente e separadamente, conforme indicado na saída.

Saída

Vantagens e desvantagens de multithreading

Mais trabalho pode ser feito mais rápido graças a multithreading. Isso ocorre porque permite que vários tópicos realizem várias tarefas de uma só vez. Multithreading Permite que os programadores realizem atividades de rede, processem fotos ou vídeos e executem cálculos complicados sem desacelerar o restante do aplicativo. Multithreading ajuda a tornar as interfaces do usuário mais responsivas. Ao executar o código que altera a tela em um encadeamento separado, o encadeamento da interface do usuário é mantido livre para realizar outras tarefas, como responder à entrada do usuário. Isso resulta em interfaces de usuário mais suaves e rápidas.

No entanto, existem algumas limitações para usar multithreading. Um dos principais desafios ao trabalhar com multithreaded Programas está evitando as condições de corrida. Uma condição de corrida é uma situação em que dois ou mais threads estão tentando acessar o mesmo recurso compartilhado ao mesmo tempo, levando a um comportamento imprevisível. Para evitar condições de raça, os desenvolvedores usam técnicas de sincronização, como mutexes, semáforos e barreiras.

Conclusão

Multithreading No C ++ é um conceito poderoso que permite aos desenvolvedores criar programas que possam executar várias tarefas simultaneamente. Ao usar a classe Thread fornecida pela biblioteca, os desenvolvedores podem criar, gerenciar e controlar vários threads. Multithreading pode ser usado para melhorar o desempenho, aumentar a capacidade de resposta e superar as limitações dos recursos do sistema. No entanto, devido aos desafios envolvidos no trabalho com multithreaded Programas, os desenvolvedores precisam ter cuidado e usar técnicas de sincronização apropriadas para evitar condições de corrida.