O fluxo de sequência único de um processo pode ser denominado um tópico. Os threads são frequentemente chamados de "processos leves", pois têm algumas características com processos. Uma classe é representar tópicos de execução distintos. Um único tópico de execução é representado pelo tópico da classe. Várias funções podem ser executadas de uma só vez por causa dos tópicos. Quando um objeto de thread é criado, ele começa instantaneamente a executar (sujeito a qualquer atraso de agendamento do sistema operacional) começando na função mais alta especificada como um construtor de funções. O valor definido do método é desconsiderado e a std :: encerrar é invocada se sair levantando um erro.

Tipos de threads

O fluxo de séries em particular de um processo é referido como um tópico. Os tópicos são indicados como procedimentos insubstanciais, pois são semelhantes aos processos de várias maneiras. Embora os threads sejam operados sequencialmente, eles parecem estar executando simultaneamente. Existem vários estados para cada tópico.

• um contador eletrônico
• um conjunto de registros
• uma área de prateleira

Processos

Em essência, os processos são os programas despachados do estado pronto e programados para execução na CPU. O conceito de processo é mantido pelo PCB (Bloco de Controle de Processos). Um processo pode produzir o que é chamado de "processos infantis" ou novos processos. O processo leva mais tempo para ser concluído porque está isolado, o que significa que não compartilha uma memória com outros processos. Qualquer um dos seguintes estados para o processo pode estar presente: novo, pronto, correndo, esperando, terminado ou suspenso.

Tópicos

Um tópico é um módulo de um processo. Um processo pode ter vários tópicos e todos esses threads estão contidos dentro do método. Três estados existem para um tópico: correndo, pronto e bloqueado. O fio termina mais rápido que o processo, mas não isolado, pois o processo.

As características comuns entre threads e processos incluem

• Apenas um tópico ou processo pode ser operativo de uma vez.
• Execução sucessiva dentro do processo.
• A capacidade de gerar crianças.

As distinções entre processos e threads

• Os processos são auto-reguladores; tópicos não são.
• Embora os processos possam ou não ajudar um ao outro, os threads são projetados para fazê -lo.

Tópico no nível do usuário

É colocado em prática na biblioteca no nível do usuário; As chamadas do sistema não são usadas para construí -las. A comutação de threads não requer uma chamada do sistema operacional ou uma interrupção do kernel. O kernel os gerencia como se fossem processos de thread único, pois não tem conhecimento do tópico em nível de usuário.

Benefícios

• Os únicos atributos que um thread tem são um espaço de pilha, um ponteiro de pilha e um registro de turno.
• Como o kernel não faz ajustes, a criação é simples.
• Devido à ausência de chamadas do sistema operacional, a troca de roscas é rápida.
• É compatível com sistemas operacionais que proíbem multi-threading.

Um tópico no nível do kernel

Os fios são gerenciados pelo kernel. Além disso, o kernel também acompanha os processos usando a tabela de processos convencionais. O kernel do sistema operacional tem chamadas de sistema para gerenciar e criar threads.

Benefícios

• Dado que o kernel tem informações completas sobre os tópicos do sistema.
• O agendador pode decidir dar processos com um alto número de threads adicionais.
• Bom para bloquear regularmente programas.

Multi-threading:

Outro nome para um tópico é um processo leve. Ao dividir um processo em vários fios, o paralelismo deve ser alcançado. Por exemplo, muitas guias em um navegador podem representar vários tópicos. Vários tópicos são usados ​​pelo MS Word, incluindo um para processamento de entradas e outro para formatar o texto.

Defina uma função Thread ()

Um tópico de classe refere -se a um determinado tópico de implementação. Em C ++, o termo "classe de thread" refere -se à classe DST :: Thread. Depois que o objeto Threads vinculado foi criado, o método de nível superior que foi fornecido como parte da concordância do construtor de funções é onde a execução do thread começa. O código de implementação que deve ser invocado receberá um novo objeto de thread que foi criado para iniciar um tópico.

Como foi dito anteriormente, o thread std :: é necessário para iniciar um novo tópico e o tópico também precisa ser chamável. Um chamável é um programa que deve ser executado quando o tópico está ativo. Em outras palavras, se um novo tópico for necessário, um chamável deve ser fornecido como um argumento ao construtor de um objeto para std :: thread. Depois disso, o encadeamento recém -gerado começa e a função fornecida é executada.

Processos vs threads

A principal distinção é que, enquanto os processos são executados em diferentes áreas de memória, encadeamentos dentro de um único processo compartilhou espaço de memória. Como os threads não são completamente independentes um do outro como processos, eles compartilham seus recursos, seção de código e seção de dados com outros threads.

Os tópicos têm vantagens sobre os processos

• Responsabilidade: se um processo for dividido em vários fios, a saída de cada fio poderá ser retornada assim que terminar de executar.
• Switch de contexto mais rápido: as alternativas de contexto entre os threads acontecem mais rapidamente do que as alternativas de contexto dentro de um processo. A CPU precisa fazer mais sobrecarga devido a mudanças de contexto de processo.
• Uso do sistema multiprocessador eficaz: se um processo contiver muitos threads, podemos agendar esses threads em diferentes processadores. Como resultado, seria uma execução de processo mais rápida.
• A comunicação é facilitada pelo fato de vários tópicos compartilharem um espaço de endereço. Enquanto estiver em processo, devemos aderir a um método de comunicação específico para comunicação de dois processos.
• Compartilhamento de Recursos: Todos os threads dentro de um processo podem compartilhar recursos como código, dados e arquivos.
• Capacidade do sistema aumentado: quando uma tarefa é separada em vários fios, todas as operações de rosca são tratadas como uma função, aumentando o número de métodos feitos em um determinado período de tempo aprimora a capacidade do sistema.

Função do thread em c++

Em um sistema operacional, eles fornecem (thread POSIX) para funções, essas funções relacionadas a funções. Podemos fazer muitos tópicos dessa maneira para apoiar o fluxo simultâneo de processos. Funciona melhor em sistemas com vários processadores ou núcleos, onde a velocidade da execução pode ser alcançada pela implementação de threads no nível do kernel. Também podem ser obtidos ganhos em sistemas com um único processador, aproveitando a IO ou outros serviços de sistema que tendem a pausar processos.

Função create ()

pthread_create: novo thread crie

Parâmetros

• Tópico: um ponteiro para um valor inteiro não assinado que contém o ID do thread do tópico mais recente que foi iniciado.
• Att: Atributos de um tópico, como seu estado isolado, estratégia de agendamento, endereço de pilha, etc., são definidos por uma estrutura chamada attr. Para propriedades padrão do thread, definido como nulo.
• Iniciar rotina: um ponteiro para a sub -rotina inicial de um tópico. A função tem apenas um atributo, mas uma estrutura deve ser usada se mais de um valor tiver que ser fornecido à função.
• Arg: Um ponteiro para um vazio que contém um ponteiro para os parâmetros da função, conforme fornecido pelo argumento anterior.

Função exit ()

pthread_exit: usado para parar de usar um tópico

Parâmetros
Revelar, um ponteiro para um número inteiro que contém o status de retorno do thread é um parâmetro necessário para este procedimento. Qualquer tópico que espera para ingressar neste tópico deve poder ver o status de retorno, porque o escopo dessa variável deve ser global.

Função junção ()

pthread_join: usado para sair do tópico esperando

Parâmetros

• TH: O fio está esperando o identificador do Thread.
• Retorno do thread: um ponteiro para o local onde o fio descrito no status de saída é salvo.

Função igual ()

pthread_equal: determina se dois tópicos são ou não semelhantes. A função retorna um número diferente de zero se os dois threads forem iguais, caso contrário zero.

ST :: Criação de threads

Em C ++, os threads são construídos usando a classe STD :: Thread. Um fio é um fluxo de execução exclusivo; É semelhante a ter um ajudante terminar uma tarefa enquanto você termina outro simultaneamente. Depois que todo o código do thread for executado, ele para. Ao estabelecer um tópico, algo deve ser passado para ser executado nele. Os objetos listados abaixo podem ser passados ​​para um tópico.

Tipos de membros

ID: ID do thread (público)
Nativo_handle_type: nativo_handle_type (público)

O encadeamento permite a execução simultânea de várias tarefas. Em C ++, o termo "classe de thread" refere -se à classe DST :: Thread. Um novo objeto de thread deve ser gerado para iniciar um segmento e deve ser fornecido ao código de execução que deve ser chamado. O método de nível superior que foi fornecido como parte da concordância do construtor de funções é onde a execução do encadeamento começa depois que o objeto Threads vinculado foi criado.

Callable utilizando objeto

Um objeto pode ser chamável, utilizando este método. Para isso, uma classe é necessária e o operador () deve ser sobrecarregado nessa classe. O software que precisa ser executado quando o tópico é formado é incluído nos métodos sobrecarregados.

Callable Utilizando ponteiro

Um ponteiro será chamável usando este método. No objeto Thread, a lista de parâmetros ou argumentos enviados ao método aparece ao lado do nome da função.

Chamável usando ponteiro de função

Dar ao objeto Thread para execução atinge o resultado desejado. O construtor de função do objeto Thread recebe uma expressão de lambda chamada "LM" como seu primeiro argumento antes de receber seus argumentos como seu segundo argumento.

Vamos discutir diferentes exemplos de std :: thread funções.

Exemplo 1

Nesse caso, utilizaremos um tópico com um ponteiro.

#incluir
#incluir
Teste de aula

público:
Execute void (comando std :: string)

para (int i = 0; i < 8; i++)

std :: cout<

;
int main ()

Teste * testptr = new test ();
std :: thread th (& test :: execute, testptr, "valores");
º.juntar();
excluir testptr;
retornar 0;

Primeiro, incluímos os arquivos dos cabeçalhos e no programa. Criamos a classe e especificamos seu nome 'teste'. Em seguida, utilizamos o método público e executamos o comando string. Depois de executar o comando string, solicitaremos o loop e o incremento (0 a 8). Aqui, empregamos a declaração 'cout'. Em seguida, chamamos a função principal (). Junto com isso, chamamos a classe de 'teste' e usamos um ponteiro nele. Em seguida, o tópico passa o ponteiro. Em seguida, estamos usando a função junção (), exclua o ponteiro de teste e digite 'retornar 0'.

Exemplo 2

Nesse caso, utilizaremos um tópico sem um ponteiro.

#incluir
#incluir
nome da classe

público:
Teste de vazio estático (comando std :: string)

para (int i = 0; i < 3; i++)

std :: cout<

;
int main ()

std :: thread th (& name :: test, "nome");
º.juntar();
retornar 0;

Use arquivos de cabeçalho e . Crie uma classe e o título da classe é 'nome'. Utilizamos o método público e a próxima linha usa uma função estática de membro e aqui passamos pela string. Use o loop 'para' e inicialize os valores de 0 a 3. A declaração 'cout' está sendo usada para representar o valor. Na próxima linha, invocamos a função principal (), usamos o fio e passamos os valores sem usar um ponteiro. Em seguida, usamos a função de junção () e digite 'Return 0'.

Exemplo 3

Aqui vamos aplicar o operador vazio.

#incluir
#incluir
usando namespace std;
Classe Lab
público:
operador void () (int a)

para (int i = 0; i < a; i++)
cout << "Number of threads :" << i << "\n";

;
int main ()

Thread T2 (lab (), 6);
T2.juntar();
retornar 0;

Neste código, integramos os arquivos de cabeçalho necessários , . Utilizamos namespace padrão como std. Adicionamos uma classe chamada 'laboratório' e usamos seu método público. Em seguida, empregue o operador vazio e inicialize uma variável 'a'. Aqui, empregaremos o loop 'para' de 0 para o valor da variável 'a'. Além disso, imprimiremos uma declaração "Número de threads" usando a declaração 'cout'. Invocamos a função principal (). Dentro disso, um tópico com o valor 6 será declarado. Quando um tópico recebe uma chamada, ele executa um código e exibe a mensagem na tela.

Conclusão

Neste guia, conversamos sobre o tópico nas funções C ++. Então, observamos diferentes funções de threads em c++. Definimos o fio e também seus tipos. Além disso, mencionamos diferentes parâmetros do tópico. Nós executamos vários tipos de códigos. No primeiro código, usamos um tópico com um ponteiro, é uma função de membro não estática. Segundo, no código, usamos threads sem ponteiro, é uma função de membro estático. Terceiro e último código, usamos o operador vazio e, quando um thread obteve o valor, mostrou a mensagem na tela.