Na aula passada discutimos padrões de criação dinâmica
de threads em programação paralela e distribuída.
No laboratório de hoje, vamos implementar os
padrões que chamei de and e or.
Vamos utilizar uma mesma rotina fazalgo
para criar um thread que irá funcionar nos dois padrões.
Essa rotina deve ter o protótipo esperado por pthread_create:
void *fazalgo(void *)sendo que o que ela recebe (ou uma das coisas que ela recebe) como parâmetro é o endereço de uma função de callback. O corpo da rotina
fazalgo deve simplesmente dormir
por um tempo aleatório, em seguida fazer uma chamada à rotina de
callback, e em seguida chamar pthread_exit.
proximaiteracao
que cria n threads, cada uma das quais irá executar a função fazalgo.
A rotina proximaiteracao termina com uma chamada
a pthread_exit.
A rotina de callback deve incrementar um contador de threads que terminaram.
Se esse número for menor que n, a rotina simplesmente retorna.
Se for igual a n, o contador deve ser zerado e a função
proximaiteracao chamada novamente.
proximaiteracao pode ser igual à anterior (acho).
A função de callback agora deve, ao ser chamada, matar as threads
diferentes da corrente e em seguida chamar proximaiteracao.
Para matar as demais threads, a função de callback deve usar
pthread_cancel. Leia a página man dessa função com
atenção para os fatores que alteram a resposta do thread a
essa função.
Verifique como seu programa deve controlar as threads para que
o cancelamento funcione.
ATENÇÃO Observe que nesses programas um grande número
de threads vai ficar sendo criado e destruído.
Pense como imprimir mensagens que permitam acompanhar a execução,
por exemplo indicando a iteração em que a thread foi criada.
A função proximaiteracao também pode utilizar um contador
estático para limitar o número total de iterações.