Multithreading em C++ é um recurso que permite executar várias tarefas simultaneamente em simultaneidade. Um thread é a unidade de trabalho de um processo específico que está sendo executado. Vários threads são executados independentemente uns dos outros ao mesmo tempo para realizar multithreading.
Como implementar multithreading em C++
Um programa multithread possui duas ou mais partes que tendem a ser executadas simultaneamente, cada parte é conhecida como thread e possui um caminho diferente para execução. Vários threads são executados independentemente uns dos outros ao mesmo tempo para realizar multithreading.
Pré-requisitos para multithreading em C++
No Windows, funções relacionadas a threads podem ser executadas em C++ 11 e versões avançadas. Ao usar o compilador Dev-C++, por padrão ele está na versão C++ 3, portanto, precisa ser alterado manualmente para a versão C++ 11. O ambiente GNU C++11 pode ser selecionado alterando as configurações padrão do idioma.
Abra o compilador Dev-C++ e vá em “Ferramentas” na barra de tarefas. Selecione “Opções do Compilador” e depois selecione “Configurações”, clique no bloco “Geração de Código” e uma lista de comandos aparecerá. Selecione GNU C++ 11 em “Language Standard(-std)” e clique em OK. Agora este compilador está pronto para suportar operações de thread.
Baixe as bibliotecas do GitHub e coloque-os na pasta lib do compilador Cpp. Chame essas bibliotecas no programa usando #include “mingw.thread.h” e arquivos de cabeçalho
std::thread thread_object ( chamável ) ;
O std::thread é suportado pelo arquivo de cabeçalho #include “mingw.thread.h” em C++ 11. É uma classe de thread e representa um único thread. Um novo thread é criado usando std::thread e um callable é passado para ele. Callable é um código executável que está sendo executado quando o thread é executado. Callable pode ser qualquer um dos três tipos fornecidos abaixo:
Quando um objeto é criado, ele lança um novo thread, que executa o código no callable.
Lançamento de Thread usando Objeto Função
Um objeto de função pode ser usado como chamável para iniciar o thread, o operador de sobrecarga () o torna chamável:
classe função_objeto_class {operador vazio ( ) ( parâmetros )
{
Declarações;
}
}
std::thread thread_object ( função_objeto_class ( ) , parâmetros )
A função de sobrecarga é fornecida ao construtor como o primeiro objeto e às instruções como o segundo objeto.
Lançamento de Thread usando Ponteiro de Função
Um ponteiro de função é definido e então usado como chamável para iniciar um thread:
função_call vazia ( parâmetro ){
Declarações;
}
std::thread thread_obj ( chamada de função, parâmetros ) ;
Os argumentos a serem passados são escritos após o nome da função.
Lançamento de Thread usando Expressão Lambda
O objeto thread pode ser iniciado usando lambda como chamável.
// Definir uma expressão lambdaautomático f = [ ] ( parâmetros )
{
Declarações;
} ;
std::thread thread_object ( f, parâmetros ) ;
A expressão lambda é definida e os parâmetros são chamados nela para iniciar o thread.
Em alguns casos, a linha de execução precisa parar antes de começar a executar o próximo comando. O std::thread::join() A função é usada para aguardar o término do thread. Por exemplo, caso atribuamos uma tarefa de GUI ao thread, precisamos aguardar o tempo de término para carregar corretamente a GUI primeiro e então ocorrerá a execução do próximo comando.
principal interno ( ){
std::thread t1 ( chamável ) ;
t1.join ( ) ;
Declarações;
}
Exemplo
Este é um programa executado para realizar multithreading usando todos os três chamáveis. Três callable diferentes executam seus respectivos comandos simultaneamente três vezes sem serem interrompidos um pelo outro:
#include#incluir
usando namespace std;
vazio foo ( interno Z )
{
para ( int eu = 0 ; eu < Z; eu++ ) {
corte << 'Thread usando função'
'ponteiro como chamável \n ' ;
}
}
classe thread_obj {
público:
operador vazio ( ) ( interno x )
{
para ( int eu = 0 ; eu < x; eu++ )
corte << 'Thread usando função'
'objeto como chamável \n ' ;
}
} ;
// Código principal
principal interno ( )
{
corte << 'Tópicos 1 e 2 e 3'
'operando de forma independente'
<< fim;
tópico th1 ( cara, 3 ) ;
tópico th2 ( thread_obj ( ) , 3 ) ;
automático f = [ ] ( interno x ) {
para ( int eu = 0 ; eu < x; eu++ )
corte << 'Tópico usando lambda'
'expressão como chamável \n ' ;
} ;
tópico th3 ( f, 3 ) ;
th1.join ( ) ;
th2.join ( ) ;
th3.join ( ) ;
retornar 0 ;
}
Neste programa, os três chamáveis, incluindo ponteiro de função, objeto de função e expressão lambda, são usados para iniciar os três threads simultaneamente. Os threads 1, 2 e 3 imprimem seus valores simultaneamente, independentes um do outro, sem serem interrompidos um pelo outro. Eles imprimem seus valores três vezes. A função join() é utilizada para aguardar o término do thread.
As saídas de todos os três threads são mostradas independentemente e repetidas três vezes. Cada thread espera que o outro termine primeiro.
Conclusão
Multithreading em C++ é um recurso que permite executar várias tarefas simultaneamente em simultaneidade. O programa multithread possui duas ou mais seções que podem ser executadas simultaneamente, cada parte é conhecida como thread e possui um caminho separado para execução. Existem três chamadas para iniciar threads, ponteiros de função, objetos de função e expressões lambda. Isso habilita o multithreading.