2.1 Jantar dos Filósofos

Oi pessoal vamos falar sobre o jantar dos filósofos um problema clássico da Ciência da Computação que foi proposto pelo cientista Edgard dxtra em 65 esse problema é fundamental para entendermos como os sistemas operacionais lidam com o uso de compartilhamento de recurso Ele explora questões de sincronização em ambiente onde vários processos precisam compartilhar recursos sem causar conflito a situação que colocamos É um cenário que representa como um processo precisa acessar recursos limitados e descreve os desafios de controlar os acessos sem gerar conflitos de sincronização levando em consideração as problemáticas que a gente tem no tema vamos

analisar um primeiro cená para analisar ambos os cenários que eu vou trazer a gente precisa considerar que um filósofo sempre precisa ter dois garfos para começar a comer Então vamos lá para esse primeiro Vamos pensar que todo mundo vai começar a comer ao mesmo tempo então todo mundo tem um garfo no início se a gente for parar para pensar bem ninguém nunca vai conseguir ter dois garfos porque ninguém nunca vai soltar o garfo que tem e por conta disso ninguém nunca vai conseguir pegar o garfo de ov para começar a comer e e os processos

V ficar ali travados e ninguém vai conseguir comer isso em sistemas operacionais a gente chama de deadlock e o deadlock ocorre quando um processo tá aguardando por um recurso que tá sendo usado por um outro processo que também está bloqueado por estar esperando um recurso e a gente entra nesse loop que a gente chama de deadlock Bora lá pro segundo cenário para esse segundo cenário a gente vai precisar levar em ação mais algumas coisas sendo a primeira delas que um dos filósofos tem menor prioridade em relação aos outros o segundo se um filósofo pega um

garfo e o outro ainda não tá disponível ele não vai ficar com esse garfo ele vai devolver diferente do caso anterior que ele pegava e só devolvia quando o processo terminasse e o terceiro é que cada filósofo vai levar um tempo diferente para comer então vamos levar em consideração o cenário em que F1 e F3 começam ali comendo e os outros estão pensando o F2 nesse caso vai ter a menor prioridade Então vamos lá quando o F1 parar de comer antes que o F3 que começou junto com ele termine ele permite que o F5 pegue

o garfo e comece a comer quando o F2 tiver preparado para ter os garfos do F1 e do F3 o F5 acaba de comer e aí o F1 tem mais prioridade que o F2 considerando que ele o F2 é sempre o de menor prioridade a gente entra aqui num problema que é o F2 nunca vai comer porque se a gente entrar nessa mesma ordem sempre o F1 sempre vai ter mais prioridade com o F2 E aí nunca vai ter um garfo disponível para ele esse processo na em sistemas operacionais a gente chama de starvation e

ele acontece quando um recurso tá ali sendo usado sempre por um um processo que tem uma prioridade maior e essa desigualdade de prioridade acaba bloqueando o que tem menos prioridade de conseguir ter acesso a esse recurso e realizar o processo que ele precisa a primeira solução para esse problema do deadlock e a mais direta é fazer com que cada filósofo só Tente pegar os dois garfos ao mesmo tempo se ele não conseguir pegar ambos ele solta o que já pegou e volta a pensar por um tempo antes de tentar novamente ou seja ele espera antes

de tentar novamente na imagem podemos ver que F2 F3 e F5 tentam comer mas apenas F3 e f F5 conseguem pegar os dois garfos então F2 devolve o garfo pra mesa e aguarda enquanto F3 termina de comer ele libera os garfos e assim F2 consegue comer outra solução é estabelecer sempre uma ordem específica para que os filósofos peguem os garfos podemos por exemplo enumerar os filósofos e fazer com que apenas um deles comece pegando o garfo à esquerda enquanto os outros começam pelo garfo à direita isso ajuda a evitar o deadlock pois impede que todos

tentem pegar os garfos ao mesmo tempo e na mesma ordem uma solução mais refinada pro nosso problema é a utilização de semáforos que são estruturas que controlam o acesso aos recursos de forma sincronizada no sistema operacional permitindo que apenas um processo acesse o recurso por vez no nosso exemplo cada garfo pode ser controlado por um semáforo garantindo assim que os dois filósofos vizinhos nunca usem o mesmo garfo ao mesmo tempo quando um filósofo deseja pegar os garfos ele checa se ambos os semáforos estão disponíveis E se eles não tiverem ele volta a pensar cada garfo

entre os filósofos é portanto representado por um semáforo iniciando com valor um esse valor indica que o semáforo está disponível quando o filósofo decide comer ele primeiro tenta pegar o garfo à esquerda se ele conseguir ele tenta pegar o garfo à direita se ambos os garfos forem pegos com sucesso o filósofo pode comer o filósofo come e ao terminar ele libera os semáforos dos dois garfos permitindo que outros filósofos utilizem assim os dois garfos voltam a ter valor um caso um filósofo não consiga pegar ambos os garfos ele libera o que já tinha pegado e

volta a pensar por um tempo antes de tentar novamente em resumo nos sistemas operacionais toda essa ideia dos filósofos é uma analogia lúdica que também se aplica na gestão de recursos em que vários processos precisam acessar recursos limitados Quando eu digo recursos são a memória a CPU ou arquivos específicos então quando nós coordenamos esses acessos Podemos evitar que o sistema fique travado ou seja em deadlock e garantimos assim que cada processo consiga fazer o seu trabalho um por vez fica aí a nossa pergunta o que que aconteceria se aumentássemos o número de filósofos na mesa

como isso afetaria a chance de deadlock ou starvation