Multithreading é o conceito de executar vários segmentos 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
Multithreading é como multitarefa. Isso significa que dois ou mais threads estão sendo executados simultaneamente. Nesse programa, cada componente é chamado de thread e cada thread especifica um caminho de execução exclusivo. Não há suporte integrado para multithreaded programas anteriores a C++ 11. Esse recurso é totalmente fornecido pelo sistema operacional.
Multithreading também pode ser chamado de divisão de um programa em threads menores que executam simultaneamente. A classe thread, que é usada para multithreading em C++, permite construir vários threads e gerenciar sua execução.
Criar Threads em C++
Para criar um thread em C++, usamos o std::thread class, que está incluída na biblioteca de encadeamentos integrada. A exigível é fornecido como um argumento para o construtor de um objeto da classe std::thread para gerar um novo thread. O código que é executado quando um thread está ativo é conhecido como exigível . quando construímos um std::thread objeto, uma nova thread é estabelecida, o que faz com que o código fornecido por exigível para ser executado. Chamável pode ser definido usando esses três métodos.
Método 1: Ponteiro de função
Chamável as funções que usam um ponteiro de função podem ser definidas assim.
void function_call ( parâmetros )
Quando a função é construída, um objeto de encadeamento contendo a função é gerado da seguinte maneira:
std::thread thread_obj ( função_chamada, parâmetros ) ;
Método 2: objeto de função
Ao utilizar o objeto de função, aproveitamos a ideia de sobrecarga do operador. O código que deve ser executado enquanto o thread está sendo formado está contido na função sobrecarregada.
classe Object_class {operador nulo ( ) ( parâmetros )
{
// código a ser executado
}
} ;
std::thread thread_object ( Object_class ( ) , parâmetros )
Método 3: Expressão Lambda
Chamável as funções que usam uma expressão lambda podem ser definidas assim.
automático f = [ ] ( parâmetros ) {// código a ser executado
} ;
std::thread thread_object ( f, parâmetros ) ;
Exemplo de Multithreading em C++
#include#include
usando namespace std;
void func_thread ( int N )
{
para ( int eu = 0 ; eu < N; i++ ) {
cout << 'Thread 1 :: callable => Usando um ponteiro de função \n ' ;
}
}
classe thread_obj {
público:
operador nulo ( ) ( int n ) {
para ( int eu = 0 ; eu < n; i++ )
cout << 'Thread 2 :: callable => Usando um objeto de função \n ' ;
}
} ;
int principal ( )
{
automático f = [ ] ( int n ) {
para ( int eu = 0 ; eu < 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.join ( ) ;
th2.join ( ) ;
th3.join ( ) ;
retornar 0 ;
}
No código acima, desenvolvemos três threads com três chamadas — um ponteiro de função, um objeto e uma expressão lambda. Cada thread é iniciada como duas instâncias separadas. Três threads estão ativos simultaneamente e separadamente, conforme indicado na saída.
Saída
Vantagens e Desvantagens do Multithreading
Mais trabalho pode ser feito mais rapidamente graças a multithreading . Isso ocorre porque permite que vários threads executem várias tarefas ao mesmo tempo. Multithreading permite que os programadores realizem atividades de rede, processem fotos ou vídeos e executem cálculos complicados sem diminuir a velocidade do restante do aplicativo. Multithreading ajuda a tornar as interfaces de usuário mais responsivas. Ao executar o código que altera a tela em um thread separado, o thread da interface do usuário fica 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 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 corrida, os desenvolvedores usam técnicas de sincronização, como mutexes, semáforos e barreiras.
Conclusão
Multithreading em C++ é um conceito poderoso que permite aos desenvolvedores criar programas que podem executar várias tarefas simultaneamente. Usando a classe de encadeamento fornecida pela biblioteca, os desenvolvedores podem criar, gerenciar e controlar vários encadeamentos. Multithreading pode ser usado para melhorar o desempenho, aumentar a capacidade de resposta e superar as limitações de recursos do sistema. No entanto, devido aos desafios envolvidos em trabalhar com multithreaded programas, os desenvolvedores precisam ter cuidado e usar técnicas de sincronização apropriadas para evitar condições de corrida.