_di0
(usa FreeBSD)
Enviado em 02/10/2011 - 04:33h
Em um Sistema Operacional, nesse caso o Linux, um processo possui algumas características e métodos necessários para serem executados.
Para implementar esses métodos, o sistema operacional utiliza-se de uma tabela, conhecida como tabela de processo, que contém entradas com informações sobre o estado do processo, sobre memória alocada, sobre a identificação do processo(PID) e outras.
A fim de não entrar em detalhe de como isso é implementado, devido a complexidade(não dificuldade), resumidamente um processo é composto ao menos de três partes: segmento de dados, segmentos de código e pilha. Atribuindo dessa forma a esse novo processo criado, o seu endereçamemto na memória.
Um sistema multi-tarefa, como é o caso do Linux, em um hardware com uma CPU, como deve saber, executa um processo por vez, técnica conhecida como paralelismo, porém de uma forma rápida causando uma nitída impressão de serem executados todos ao mesmo tempo.
Essa forma de como são tratados os processos, são de responsabilidades dos sistemas operacionais, que obviamente foram projetados, desenhados, são mantidos e melhorado por estudos envolvendo grupos de cientistas da computação e engenheiros na área de desenvolvimento de softwares, que ao longo dos anos, foram adicionando novas técnicas.
Dentre essas, surgiram as Threads, que trata-se de uma maneira de o processo dividir a sim mesmo em uma ou mais tarefas, que podem ser executados concorrentemente.
Um exemplo bem simples, seria um processo responsável por ler e/ou escrever em dois arquivos textos. O processo poderia se dividir em duas tarefas: Enquanto uma thread é responsável por ler de um arquivo, a outra thread poderia escrever. Realizando dessa forma uma tarefa concorrentemente, dependendo de como foram projetados pelo programador.
Há uma maneira similar de se dividir uma tarefa, que no caso é a criação de um outro processo e não a divisão do mesmo. A criação de um novo processo, como deve saber, é realizada com a chamada de sistema fork(), que ao contrário da forma de como é implementada uma thread, cria um novo processo, idêntico ao processo que o criou.
Porém, além do thread ser de implementação mais simples e mais segura, é também mais rápido, pois partilham do mesmo espaço de endereçamento do processo que o dividiu.
No campo da programação, mas especificamente na linguagem de programação C, é disponibilizado no Linux a biblioteca pthread.h. Nela existe o protótipo:
/*
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine)(void*), void *arg);
*/
responsável pela criação das threads usadas por um programa qualquer.
Cada nova thread criada, é representada com o um identificador, que é passada através do primeiro argumento do protótipo citado acima
(pthread_t *thread).
É através desse ponteiro que vamos referenciar(identificar) as threads.
Quando se cria uma thread, ela só termina quando retornar ou quando a
mesma invocar a terminação.
Quando uma thread termina, o seu valor de retorno não é destruído, ficando retído na memória. Esse valor de retorno, o qual ficou em dúvida, é um valor apontador genérico(void *) e que contém qualquer tipo de resultado.
Por exemplo, uma thread(função) que foi criada para somar dois inteiros e retonar os valores.
Devido a isso, que você leu em algum lugar isso:
---------------------------------------------------------------------------
"Por padrão, o resultado da execução de todas as threads são guardados até que façamos um pthread_join para recuperar o resultado"
---------------------------------------------------------------------------
Isso quer dizer que você pode recuperar esses valores retornados através desse método(pthread_join).
Outra dúvida sua:
--------------------------------------------------------------------------
"estava vendo um tutorial e nessa parte ele fala isso: int pthread_detach(pthread_t th)
* Esta função indica para a biblioteca que não queremos que o resultado da thread indicada por th seja guardado..."
---------------------------------------------------------------------------
O que o autor do texto acima quis dizer, é que é possível criar threads que não são "joinable", ou seja, quando terminam, libertam todos os recursos, incluindo o valor de retorno, não os guardando.
Para se fazer isso, pode ser usar o método pthread_detach(pthread_t th), onde o th é o identificador da thread que não deseja que seja mantido o valor, como diz o texto que você colou.
Enfatizo no entanto, que não é possível mais esperar valores com o método pthread_join, já que foram destruídos com o outro método, pthread_detach.
