Menu

Multithreading em C ++ com exemplos

multithreading c with examples

Experimente Nosso Instrumento Para Eliminar Problemas

Uma breve introdução ao multithreading em C ++.

Neste tutorial, teremos uma visão geral do multithreading em C ++.

Então, o que é um tópico? Um thread é uma unidade de trabalho de um processo específico. Em sistemas operacionais de multiprogramação, diferentes processos são executados simultaneamente.

De maneira semelhante, podemos querer executar as mesmas instâncias de processo simultaneamente. Cada instância de processo, neste caso, é atribuída a uma unidade de execução chamada thread. Em um sistema multithreading, vários threads são executados simultaneamente, independentemente uns dos outros.

=> Dê uma olhada no guia para iniciantes em C ++ aqui.

MULTITREAGEM EM C ++

aplicativo de download de música mp3 grátis para Android

Antes do C ++ 11, tínhamos suporte a thread POSIX. Mas esse recurso tinha sérios problemas de portabilidade, pois funcionava apenas no sistema operacional Linux ou UNIX. Assim, do C ++ 11 em diante, temos uma única classe std :: thread que define todas as funcionalidades dos threads. As classes e funções são definidas no arquivo de cabeçalho.

O que você aprenderá:

Trabalho de

Usando std :: thread, simplesmente precisamos criar um novo objeto de thread e passá-lo a um chamável. Um chamável é um código executável que queremos executar quando o thread está em execução. Portanto, sempre que queremos um novo thread, apenas criamos um objeto de std :: thread e passamos um chamável como um argumento para seu construtor.

Depois que o objeto std :: thread é criado, um novo thread é iniciado e o código fornecido por callable é executado.

Vamos ver como podemos definir um chamável a ser fornecido ao objeto thread.

Um chamável pode ser definido de três maneiras.

# 1) Usando o objeto Function

Podemos usar um objeto de função como um callable no objeto thread. Para usar o objeto de função, precisamos ter uma classe e nessa classe, sobrecarregamos o operador (). Essa função sobrecarregada contém o código a ser executado quando o thread é criado.

/ / Define the class for function object class functioObject_class { // Overload () operator void operator()(params) { // code to be executed } }; // Create thread object std::thread thread_object(functioObject_class (), params)

Observe a maneira como o objeto thread é definido. Como o primeiro parâmetro para o construtor do objeto thread, fornecemos a função sobrecarregada e, em seguida, especificamos seus argumentos (params) como o segundo argumento.

# 2) Usando o ponteiro de função

Um ponteiro de função que pode ser chamado pode ser definido da seguinte maneira.

void funct_call(params) //code to be executed }

Depois de definir essa função, podemos criar um objeto thread com essa função como chamável, da seguinte maneira.

std::thread thread_obj(funct_call, params);

Observe que os argumentos (parâmetros) passados ​​para a função são fornecidos após o nome da função no objeto thread.

# 3) Usando uma expressão Lambda

Também podemos ter um chamável como uma expressão lambda e passá-lo para o objeto thread para execução. O trecho de código para o mesmo é mostrado abaixo.

// Define a lambda expression auto f = ()(params) { // code for execution }; std::thread thread_object(f, params);

No código acima, definimos uma expressão lambda f e então a passamos para o construtor do objeto thread como o primeiro argumento seguido por seus parâmetros (params) como o segundo argumento.

std::thread join method

Em alguns casos, podemos querer que o encadeamento atualmente em execução termine antes de iniciarmos outra ação.

Um exemplo clássico é quando abrimos o aplicativo GUI. No momento em que abrimos o aplicativo, uma thread para carregar e inicializar a GUI é iniciada e não podemos realizar nenhuma ação a menos que o carregamento e a inicialização sejam feitos corretamente para garantir que a GUI funcione corretamente.

A classe std :: thread fornece um método join () que garante que o thread atual (apontado por * this) termine antes de qualquer outra ação ser executada.

Veja o seguinte exemplo,

int main() { std::thread t1(callable_code); ….. t1.join(); ….. }

No exemplo acima, a função principal terá que esperar para continuar até que o thread t1 termine. Em geral, a função de junção de thread bloqueia outras ações / funcionalidade até que a chamada de thread termine sua execução.

Exemplo de linha

Apresentamos um exemplo de codificação completo para criação e execução do thread no programa mostrado abaixo.

#include #include using namespace std; // function to be used in callable void func_dummy(int N) { for (int i = 0; i

Resultado:

Thread 1 :: callable => ponteiro de função
Thread 1 :: callable => ponteiro de função
Thread 3 :: callable => expressão lambda
Thread 3 :: callable => expressão lambda
Thread 2 :: callable => objeto de função
Thread 2 :: callable => objeto de função

No exemplo acima, criamos três threads usando três chamadas diferentes, ou seja, ponteiro de função, objeto e expressão lambda. Criamos 2 instâncias de cada thread e as iniciamos. Conforme mostrado na saída, três threads operam simultaneamente de forma independente uma da outra.

Leitura recomendada = >> Guia de teste de thread

Conclusão

Neste tutorial, vimos os conceitos de multithreading em C ++ com um exemplo claro. Em nossos tutoriais subsequentes, aprenderemos mais tópicos C ++ que nos ajudariam a escrever programas robustos e eficientes.

=> Leia a série de treinamento Easy C ++.

Leitura recomendada

^