Problemas ao usar Threads

[Lucas Alves_711535]

Ola pessoal. Bom tenho que entregar um trabalho sobre threads na segunda porém não sei utilizar threads e semaforos. se vocês puderem me ajudar com qualquer coisa já seria muito bom aqui esta a ordem do trabalho:

 

 

ENUNCIADO:
Este trabalho tem por objetivo fazer com que os alunos experimentem na prática a programação de
problemas de sincronização entre processos e os efeitos da programação concorrente. Isso deve ser feito
utilizando-se os recursos de threads POSIX (pthreads) — em particular, mutexes (pthread_mutex_t) e variáveis
de condição (pthread_cond_t).
O PROBLEMA:
Sheldon, Leonard e Howard compraram um forno microondas juntos. Para decidir quem podia usar o
forno, defiiram o seguinte conjunto de regras:
• se o micro-ondas estiver liberado, quem chegar primeiro pode usar;
• caso contrário, obviamente, quem chegar depois tem que esperar;
• se mais de uma pessoa estiver esperando para usar, valem as precedências:
– Sheldon pode usar antes do Howard;
– Howard pode usar antes do Leonard;
– Leonard pode usar antes do Sheldon.
• quando alguém termina de usar o forno, deve liberá-lo para a próxima
pessoa de maior prioridade, exceto em dois casos:
– para evitar inanição (discutido a seguir);
– quando houver deadlock (um ciclo de prioridades).
Como agora os personagens do show The Big Bang Theory têm namoradas (Leonard tem a Penny,
Howard tem a Bernardette e Sheldon tem a Amy, caso você não saiba), elas entram no esquema do forno da
seguinte forma: cada namorada tem a mesma prioridade do namorado. Só que se os dois quiserem usar o
microondas, um tem que esperar depois do outro. (Quer dizer, se Penny, Leonard e Howard estiverem
esperando para esquentar algo e ninguém mais chegar, Howard usa primeiro pois tem priordade sobre
Leonard/Penny, depois usa o forno Penny ou Leonard, dependendo de quem chegou primeiro entre eles; mas se
a Bernardette chegasse antes do Howard acabar, ela teria preferência de usar em seguida a Howard (antes de
Penny ou Leonard).
Observe que isso pode levar à inanição em casos de uso intenso do forno, daí é preciso criar uma regra
para resolver o problema: se o casal usar o forno em seguida, o segundo é obrigado a ceder a vez para um
membro do casal que normalmente teria que esperar por eles. Obviamente, o segundo membro do casal só
pode usar o forno se nesse meio tempo não chegar alguém com maior prioridade.
Cada personagem, como os fiósofos daquele famoso problema, dividem seu tempo entre períodos em
que fazem outras coisas e períodos em que resolvem esquentar algo para comer. O tempo que cada um gasta
com outras coisas varia entre 3 e 6 segundos e usar o forno gasta um segundo. (Os tempos das outras coisas
são apenas uma referência, você pode experimentar tempos um pouco diferentes, se for mais adequado.
Certifiue-se de que em alguns casos esses tempos sejam sufiientes para gerar alguns deadlocks de vez em
quando, bem como situações que exijam o mecanismo de prevenção de inanição.
Se você reparar as precedências defiidas, vai notar que é possível ocorrer um deadlock (Sheldon →
Howard → Leonard → Sheldon) — é, eles sabem, mas são muito teimosos para mudar. Para evitar isso, o Raj
periodicamente (a cada 5 segundos) confere a situação e, se encontrar o pessoal travado (forno vazio e alguém
de cada casal esperando), pode escolher um deles aleatoriamente e liberá-lo para usar o forno.
IMPLEMENTAÇÃO
Sua tarefa neste trabalho é implementar os personagens do show The Big Bang Theory como threads e
implementar o forno como um monitor usando pthreads, mutex e variáveis de condição.
Parte da solução requer o uso de uma mutex para o forno, que servirá como a trava do monitor para as
operações que os personagens podem fazer sobre ele. Além da mutex, você precisará de um conjunto de
variáveis de condição para controlar a sincronização do acesso dos casais ao forno: uma variável para enfieirar
o segundo membro de um casal se o outro já estiver esperando, e outra variável de condição para controlar as
regras de precedência no acesso direto ao forno.
O programa deve criar os sete personagens e receber como parâmetro o número de vezes que eles vão
tentar usar o forno — afial, não dá para fiar assistindo eles fazerem isso para sempre. Ao longo da execução o
programa deve então mostrar mensagens sobre a evolução do processo. Por exemplo:
$ ./trabalho_so 2
Sheldon quer usar o forno
Sheldon começa a esquentar algo
Leonard quer usar o forno
Howard quer usar o forno
Amy quer usar o forno
Sheldon vai comer
Penny quer usar o forno
Raj detectou um deadlock, liberando Howard
Howard começa a esquentar algo
Sheldon quer usar o forno
Howard vai comer
Leonard começa a esquentar algo
Leonard vai comer
Penny quer usar o forno
Leonard quer usar o forno
Amy começa a usar o forno
...
Nota: a ordem dos eventos acima deve variar entre execuções (escalonamento das threads) e implementações.
Você não deve esperar ter exatamente o mesmo resultado.
Sumarizando:
• membros do mesmo casal esperam um atrás do outro para usar o forno;
• as regras de preferência defiidas acima valem a não ser que um casal tenha que ceder a vez;
• deadlock deve ser resolvido pela atuação do Raj;
• inanição deve ser evitada pela regra do casal ceder a vez.
Para implementar a solução, analise as ações de cada personagem em diferentes circunstâncias, como
o outro membro do casal já está esperando, há alguém com mais prioridade esperando, há alguém com menos
prioridade esperando. Determine o que fazer quando alguém decide que quer usar o forno e tem alguém de
maior prioridade, o que fazer quando terminam de usar o forno, etc.
Consulte as páginas de manual no Linux para entender as funções da biblioteca para mutex e variáveis
de condição (cond):
• int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
• int pthread_mutex_lock(pthread_mutex_t *mutex);
• int pthread_mutex_unlock(pthread_mutex_t *mutex);
• int pthread_mutex_destroy(pthread_mutex_t *mutex);
• int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
• int pthread_cond_signal(pthread_cond_t *cond);
• int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
• int pthread_cond_destroy(pthread_cond_t *cond);
Como mencionado anteriormente, você deve usar uma mutex para implementar a funcionalidade
equivalente a um monitor, isto é, as operações sobre o forno serão parte de um monitor. Na prática, isso será
implementado em C, mas deverá ter a funcionalidade equivalente a:
//PSEUDOCÓDIGO
monitor forno
{
... // variáveis compartilhadas, variáveis de condição
void esperar(int personagem) {
printf("%s quer usar o forno\n", nome(personagem));
... // verifica quem mais quer usar, contadores, variáveis de cond., etc.
}
void liberar(int personagem) {
printf("%s vai comer\n", nome(personagem));
... // verifica se tem que liberar alguém, atualiza contadores, etc.
}
void verificar() {
... // Raj verifica se há deadlock e corrige­o
}
};
Os personagens com namoradas(os) executam as seguintes operações um certo número de vezes (defiido
pelo parâmeto de entrada na execução do programa):
forno. esperar(p); // exige mutex
esquentar_algo(p);  // não exige exclusão mútua
forno. liberar(p); // exige mutex
comer(p);  // espera um certo tempo aleatório
Use srand() (confia a página do manual) para gerar números aleatórios entre 0 e 1, use uma multiplicação para
gerar inteiros aleatórios.
Já o personagem Raj executa as seguintes operações:
enquanto personagens estão ativos faça
sleep(5);
forno.verificar();
INFORMAÇÕES ÚTEIS
Forma de operação
O seu programa deve basicamente criar uma thread para cada personagem e esperar que elas
terminem. Cada personagem executa um loop um certo número de vezes (parâmetro de entrada na linha de
comando), exceto Raj, que deve executar seu loop até que todos os outros personagens tenham acabado.
Codifiação dos personagens
Você deve buscar ter um código elegante e claro. Em particular, note que o comportamento dos casais é
basicamente o mesmo, você não precisa replicar o código para diferenciá-los. Além disso, o comportamento de
todos os personagens (exceto o Raj) é tão similar que você deve ser capaz de usar apenas uma função para
todos eles, parametrizada por um número, que identifiue cada personagem. As prioridades podem ser
descritas como uma lista circular.
Acesso às páginas de manual
Para encontrar informações sobre as rotinas da biblioteca padrão e as chamadas do sistema
operacional, consulte as páginas de manual online do sistema (usando o comando Unix man ). Você também vai
verifiar que as páginas do manual são úteis para ver que arquivos de cabeçalho que você deve incluir em seu
programa. Em alguns casos, pode haver um comando com o mesmo nome de uma chamada de sistema;
quando isso acontece, você deve usar o número da seção do manual que você deseja: por exemplo, man read
mostra a página de um comando da shell do Linux, enquanto man 2 read mostra a página da chamada do
sistema.
Manipulação de argumentos de linha de comando
Os argumentos que são passados para um processo na linha de comando são visíveis para o processo
através dos parâmetros da função main():
int main (int argc, char * argv []); 
o parâmetro argc contém um a mais que o número de argumentos passados (no caso deste enunciado o argc
deverá ter valor igual a 2) e argv é um vetor de strings, ou de apontadores para caracteres (no caso deste
enunciado o número de iterações deverá ser obtido em argv[1] ).
Processo de desenvolvimento
Lembre-se de conseguir fazer funcionar a funcionalidade básica antes de se preocupar com todas as
condições de erro e os casos extremos. Por exemplo, primeiro foque no comportamento de um personagem e
certifiue-se de que ele funciona. Depois dispare dois personagens apenas, para evitar que deadlocks
aconteçam. Verifiue se os casais funcionam, inclua o Raj e verifiue se deadlocks são detectados (use um
pouco de criatividade no controle dos tempos das outras atividades para forçar um deadlock). Finalmente,
certifiue-se que o mecanismo de prevenção da inanição funciona (p.ex., use apenas dois casais de altere os
tempos das outras atividades para fazer com que um deles (o de maior prioridade) esteja sempre querendo
usar o forno. Exercite bem o seu próprio código! Você é o melhor testador dele!!!

 

 

 

 

por favor se puderem me ajudar