Pthread_function na linguagem C

O padrão POSIX nos dá a possibilidade de desenvolver programas multithreaded no idioma C. Esta técnica de programação consiste em usar a biblioteca “Pthread” para abrir um ou mais threads de subprocessos que correm em paralelo com o processo principal.

A implementação de threads traz grandes benefícios ao programa final, pois acelera os tempos de execução executando várias tarefas simultaneamente, pode ser melhor estruturada e faz um melhor uso dos recursos do sistema.

Um tópico é criado com a função pthread_ create (). Depois que essa função é chamada, o thread começa a funcionar em paralelo com o processo principal. Quando essa função é chamada, ele retorna o ID do thread no tópico de argumento de saída. Este identificador é usado para se referir ao thread criado quando você usa as funções de gerenciamento de threads como pthread_join () ou pthread_cancel ().

Neste artigo da dica do Linux, você aprenderá como usar a função pthread_cancel (), uma das funções de gerenciamento de encadeamentos C que permitem cancelar um tópico que já está executando.

Sintaxe da função pthread_cancel () na linguagem C

int pThread_cancel (thread Pthread_t);

Descrição da função pthread_cancel () na linguagem C

A função pthread_cancel () envia uma solicitação ao sistema para cancelar o thread especificado pelo identificador em seu thread de argumento de entrada.

A chamada para a função pthread_cancel () não implica rescisão imediata do thread, mas um pedido para fazê -lo. Se um tópico é encerrado após chamar essa função depende dos atributos que são atribuídos a ele quando é criado. Se um tópico for criado com seus atributos padrão, ele poderá ser cancelado.

Os atributos de cancelamento de um thread podem ser recuperados com a função pthread_setCancelstate () e podem ser definidos com pthread_setcanceltype ().

Se a função pthread_cancel () for bem -sucedida, ele retornará 0 como resultado. Se falhar, retornará um valor diferente de zero.

A função pthread_cancel () da biblioteca Pthread é definida no “Thread.H ”cabeçalho. Para usar isso e as outras funções de gerenciamento de threads, você deve incluir este cabeçalho no seu programa da seguinte forma:

#incluir

Os programas que usam as funções de gerenciamento de threads devem ser compilados chamando a biblioteca de threads da linha de comando Linux. Caso contrário, os erros ocorrerão.

A seguir, é apresentada uma seção especial que explica como compilar corretamente os programas que usam as funções da biblioteca de threads.

Como cancelar um tópico em execução usando a função pthread_cancel () na linguagem C

Neste exemplo, criamos um tópico com a função pthread_create () e depois o cancelamos no meio da execução com a função pthread_cancel ().

Para fazer isso, criamos o thread "Thread_1" que executa a função th_function () que consiste em um loop for 10 ciclos, cada um dos quais imprime o “Segundos do thread init e o número de segundos decorridos” frase no console de comando. Depois disso, um atraso de 1 segundo é inserido para repetir o ciclo novamente. Então, o tempo de execução do tópico é de cerca de 10 segundos.

Depois que o Thread_1 é criado e em execução, introduzimos um atraso de 5 segundos através da função principal () e encerrarmos o subprocesso após metade do tempo de execução. Para encerrar o thread, chamamos a função pthread_cancel () e passamos o identificador Thread_1 que é retornado pela função pthread_create () como entrada quando o thread é criado. Agora, vejamos o código deste exemplo:

#incluir
#incluir
#incluir
#incluir
void * th_function (void * n);
void main ()

pthread_t thread_1;
pthread_create (& thread_1, null, & th_function, null);
sono (5);
pthread_cancel (thread_1);
sono (5);

/***************************************************** *****/
void * th_function (void * n)

para (int sec = 0; seg!= 10; sec ++)

printf ("segundos do thread init %i \ n", segundo);
sono (1);

A imagem a seguir mostra a compilação e execução do código. Como você pode ver, o thread é encerrado com a função pthread_cancel () no meio da execução ou 5 segundos após o início:

Nesse caso, o encadeamento aceita o cancelamento porque seus atributos estão definidos como padrão na criação, especificando um ponteiro nulo nos argumentos de entrada "att" da função pthread_create ().

Erros no uso da função pthread_cancel (): o que eles são e como identificá -los

A maneira de determinar se ocorre um erro ao chamar essa função é usar uma condição "se" em que a condição de entrada seja um resultado de retorno diferente de zero. A seguir, é apresentado um snippet de código usando este método para detecção de erros:

if (pthread_cancel (thread) != 0)
printf ("Ocorreu um erro tentando cancelar o thread especificado");

O único erro que essa função pode gerar é a que é definida como ISrch no “errno.H ”cabeçalho. Este erro é gerado quando um encadeamento inexistente é referenciado no argumento de entrada da função pthread_cancel ().

Erros de compilação em programas com threads

Ao compilar os programas GCC que usam threads, a compilação pode falhar se não for feita corretamente na linha de comando.

A mensagem de erro mais comum que é emitida pelo compilador afirma que uma das funções do encadeamento a que nos referimos no código não é definida.

Esses erros geralmente resultam em desperdiçar tempo valioso, verificando os cabeçalhos que inserimos no código, sua integridade e os diretórios associados ao compilador, pois tudo indica que o problema está lá.

Embora as funções que causam o erro sejam definidas no “Pthread.h " Cabeçalho e estão incluídos no código, o compilador não reconhece essas funções, a menos que a biblioteca Pthread seja chamada da linha de comando durante a compilação.

Você pode ver em verde a maneira correta de chamar a biblioteca PTHread do console de comando durante a compilação de programas com threads no seguinte:

~ $ gcc -phread caminho/nome de arquivo.C -O out_name

Como podemos ver na figura a seguir, o erro desaparece quando a biblioteca do PTHread é chamada durante a compilação:

Conclusão

Neste artigo da dica do Linux, mostramos como usar a função pthread_cancel () para pedir ao sistema para encerrar um tópico em execução.

Observamos uma descrição teórica desta função e mostramos sua sintaxe, os argumentos de entrada e saída e o tipo de dados que cada um deles aceita. Depois disso, implementamos o que aprendemos através de um exemplo prático com trechos de código e imagens onde vimos como a função pthread_cancel () funciona na linguagem C.

Também adicionamos uma seção especial em que mostramos como compilar corretamente os programas que contêm os threads e funções da biblioteca Pthread.