Processos e Threads 

1. Toda vez que vai ocorrer uma mudança de processo rodando(quando ambos estão 
ainda rodando), ocorre um chaveamento de contexto entre processos, o que ele faz é 
salvar todas informações do processo atual e carregar as informações do próximo 
processo e executar. 
a. As informações Salvas são: 
i. Prioridade 
ii. Local da memória caso o processo utilize 
iii. Contexto (instrução em execução e valores nos registradores) 
iv. Dono do processo 
v. Tamanho da memória utilizada 
vi. Contabilidade de recursos utilizados como I/O, memória e processador* 
vii. Estado do processo 

 
2. Multithreading ajuda principalmente a otimizar o uso do computador, por exemplo, ao 
realizar uma soma o CPU vai fazer muito rápido, mas ao esperar uma I/O se a aplicação 
for single thread ela ficará parada esperando, se for multithreading 1 thread pode cuidar 
do I/O em questão e a outra pode continuar rodando e executando funções mais 
rápidas enquanto espera a entrada ou saída terminar a comunicação.  
 
Ou seja melhora o desempenho do software, visto que consegue utilizar melhor os 
 recursos. 
 
 

 
3. 2^n​ onde N é o número de forks, logo, como temos 3 forks. 
2³ = 8​ = número de processos criados. 
Se não contar o pai, seriam 2^n -1. 
 

 
4. t1:=3; t2:=3;  
(contadores, para cada join triplo que tem no grafo) 
P1; fork a2; fork a4; fork a3; quit;  
(P1 é executada, tem um fork para P2, P4 e P3, quit no final de cada comando) 
  a2: P2; fork a7; fork a5; quit; 
(para cada aN, executa o respectivo Processo, se for join, sinaliza o contador que está dando join 
 , próximo aN) 
a3: P3; fork a6; fork a8; quit; 
a4: P4; join t1, a9; quit; 
a5: P5; join t1, a9; quit; 
a6: P6; join t1, a9; quit; 
a7: P7; join t2, a10; quit; 
a8: P8; join t2, a10; quit; 
a9: P9; join t2, a10; quit; 
a10: P10; quit; 
 

 
5. Primeiro, post que pode ajudar a elucidar vários conceitos: 
https://stackoverflow.com/questions/15983872/difference-between-user-level-and-kern
el-supported-threads 
 
User threads: gerenciadas por user-level-libraries, sem suporte ao kernel 
Kernel threads: gerenciadas diretamente pelo SO. 
n 
Tipos de mapeamento: 

 
 
Vantagens e Desvantagens: 

 
  
 

 
6. São alocados para processos: dados, código, heap e stack; 
Para threads são alocados e dividem com os processos os código e dados, variáveis 
globais, arquivos abertos, diretórios, informações do SO, etc. Além disso elas têm uma 
stack separada, registradores, incluindo stack pointer(SP) e program counter(PC). 
 
São considerados mais leves que processo pois tem um share de memória, ou seja, o 
chaveamento de contexto acontece muito mais rápido que um processo faria. 

 
CAIU NA PROVA 2017/1 
7. Como o pid == 0 é referente ao filho, ele acrescenta 5 ao inteiro “value” mas não dá o 
print dele, lembrando que as variáveis são diferentes do pai e do filho, são copiadas. 
 
Pid > 0 é do processo pai, logo ele vai printar o valor do processo pai que é 5. 
Na linha A portanto vai ser impresso 5. 
wait(NULL) faz com que o pai execute só depois que todos filhos terminarem 
  
8. C1; C2; C3 executados em sequencia: 
● x = 5 
● y = 2 

Executa C1, C2 e C3 em paralelo 

● X e Y podem assumir valores 

○ Se C2;C1;C3, x = 2, y = -3 
○ Se C2;C3;C1, x = 2, y = -3 
○ Se C1;C2;C3, x = 5, y = 2 
○ Se C1;C3;C2, x = 2, y = -3 
○ Se C3;C2;C1, x = -11, y = -8 
○ Se C3;C1;C2, x = 2, y = -3 

(Espera x > y e executa C1 depois C2) ao mesmo tempo que (executa C3) 

● x nunca será maior que y, somente executando C2 primeiro que isso 

ocorre. 
● Executando C3 primeiro, tornará o valor de x menor ainda. 

Programação concorrente e princípios sobre sincronização 

 
1. É quando diferentes processos acessam e manipulam dados concorrentemente. 
Resultado depende da ordem que são executados. 

 
2. É quando um processo ou uma thread está esperando para que alguma condição 
aconteça para continuar executando. Para evitar, temos diversas técnicas como 
at-most-once, funções atômicas, etc. 
 

 
3.  

 
4. Satisfaz pois tem no máximo uma referência(y = x - y) de uma variável(x) em outra etapa 
concorrente. 
 
Os valores finais podem ser: 
x = 2 
y = 1 
 
Ou 
 
x = 2 
y = 0 

 
5. Não, para ocorrer deadlock, devemos ter alguma dessas quatro situações: 
a. Exclusão Mútua​: um recurso não pode ser usado por mais de um processo; 
b. Pare e espere​: processos que já estão segurando recursos podem requisitar 
novos recursos 
c. Sem preemptividade​: Nenhum recurso pode forçadamente ser retirado de um 
processo que o está segurando, recursos podem ser liberados explicitamente e 
somente pelo processo. 
d. Espera Circular​: 2 ou mais processos formam uma cadeia circular onde cada 
processo espera para um recurso que o outro processo está segurando; 
 
Logo, para termos deadlocks, temos que ter ou multithreading ou vários 
processos ou os 2. 
 
 
  
6. O caso em que o starvation ocorre é quando um processo está esperando para ser
atendido, mas sempre chega outro processo que é escolhido pelo escalonador.

Para resolver o starvation podemos simplesmente criar uma ordem de escalonamento

de timpressão.
 

// Imagino que para solucionar o problema de o processo nunca ser

escalonado, deveria ser criado uma espécie de prioridade para cada processo
que aumenta com o tempo
 
Pode corrigir usando herança de prioridade 
 
 
 
 

 
7. Propriedades primitivas de exclusão mútua: 
a. Exclusão Mútua: garantir que no máximo um processo esteja executando uma 
seção crítica; 
i. Como tem a variável booleana wantsToEnter e mais uma variável turn 
que indica se é a vez do processo em questão, ele nunca vai ter 2 
processos executando a seção crítica. 
b. Progressão: Um processo fora da seção crítica não pode impedir outro de entrar; 
i. Como existem as 2 variáveis explicadas em A, o processo fora da seção 
crítica vai alternar ao final da execução de cada um deles, logo o outro 
também vai ter a sua vez, sem impedimentos. 
c. Espera limitada: Um processo não deve ser proibido indefinidamente de entrar 
em uma seção crítica 
i. Mesmo motivo da B, existe uma alternância entre os processos. 
d. Não deve fazer suposições sobre velocidade relativa do computador, ou 
execução relativa a velocidade dos processos. 
 i. Não existem suposições que dependam de velocidade do computador, 
existe um controle de variáveis.  

 
8. Se por exemplo, P1 é executado, e na região não crítica ele demora muito executar, 
depois de ter alterado o turn, o processo P2 vai executar, ao terminar vai setar uma flag 
contrária a sua execução, então se P1 ainda estiver executando a seção não crítica ele 
vai tentar executar novamente(o P2) e assim ele estaria esperando e sendo bloqueado 
pois P1 não chegou no turn novamente. 
 

 
9. Busy-wait num sistema com um único processador implica em tempo perdido de 
execução já que o processo só está ocupando a cpu sem fazer nada. Em sistemas 
multicore isso pode ser aceitável já que outras threads estarão executando em paralelo 
e o fato de não ter troca de contexto do processo em busy wait, pode fazer valer a pena 
ele ficar executando "nada" contando que seja liberado logo. 

 
10. Porque dá muito poder ao usuário, pode acontecer de um processo ser executado 
infinitamente(loop) e se entrar não irá sair. 
 

 
  
 

 
11. Como os 2 estão acessando uma mesma conta, pode acontecer de que ao passar a 
quantia a ser retirada, ele reconheça como a quantia a ser depositada na função de 
depósito. Ou que o marido retire a quantia que a esposa está tentando depositar, enfim, 
conflito de dados. 
 
Para resolver essa situação exclusão mútua pode ser aplicada, considerando cada 
função como uma seção crítica. 
 
Saldo: 100 
Deposito: 80 
Saque: 20 
Ambas operações são feitas de forma concorrente 
 
terminal A: operação deposito, saldo = 100 
Terminal B: operação saque, saldo = 100 
Terminal A: soma 50 ao saldo de 100 
Terminal B: subtrai 80 de 100 
Terminal A: salva saldo 150 
Terminal B: salva saldo de 20 
Depósito foi perdido 
-> implementar seção crítica com mutex ou algo do tipo 
 
 
 
 
 
 

Primitivas de sincronização: mutex, semáforos, monitores 

 
1. Diferenças e Conceito 
a. Mutex 
i. Mutex deixam somente uma thread por vez entrar na seção crítica e 
somente essa thread pode liberar o mutex. 
 
No semáforo, pode ser sinalizado de qualquer outra thread ou processo a 
liberação. Por esse motivo semáforos são mais adequados para 
problemas de sincronização como produtor-consumidor. 
 
O mesmo mutex pode ser compartilhado entre vários processos, 
consequentemente várias threads entre esses processos. 
 
b. Semáforos 
i. O semáforo faz o mesmo com o mutex com a diferença de que podem 
entrar X processos dentro dessa seção crítica. 
 
Assim como mutex, podem ser utilizados por vários processo e threads, 
lembrando que os semáforos podem liberar ou alocar recursos de 
qualquer outra thread/processo. 
 
c. Monitores 
i. Monitores, assim como mutex só deixam uma thread/processo executar 
a seção critica, são feitos para multi-thread dentro de um único processo. 
  
2.  
a) turn = 2; 
b) p2WantsToEnter = 1 && turn = 2; 
c) turn = 1; 
d) p1WantsToEnter = 1 && turn = 1; 

 
3. Será violada pois se V pode interferir em P ou o contrário, pode interferir na contagem 
de recursos que o semáforo está controlando no momento. Logo mais de uma thread 
poderia por exemplo usar o mesmo recurso. 

 
4. Sem arrive1=0,  
arrive2=0; 
Process Worker1 {  
 V(arrive1); 
P(arrive2) 
}  
Process Worker2 { 
V(arrive2);  
P(arrive1); 
} 

 
5. Poderiamos utilizar dois semáforos inicializados em zero, semaforoA e semaforoB.  
threadA: tarefa Y threadB: tarefa X 
semaforoA.V() semaforoB.V() 
semaforoB.P() semaforoA.P() 
Tarefa A tarefa B 
 
 

 
6. Porque caso os semáforos sejam inicializados em zero, vai dar deadlock pois a thread 1 
vai estar esperando o recurso do semaforoB e a thread 2 vai estar esperando o recurso 
do semaforoA. Caso sejam inicializados em 1+, a thread 1 pode executar a tarefa A 
 antes da tarefa X ser executada, assim como a B pode executar a tarefa B antes da 
tarefa Y. Nesse caso, os semáforos acabam não tendo sentido. 

 
7. P = tirar recurso 
V = repor recurso 
 
Se executarmos começando em 1, 12 operações P’s, ficaremos com -11, ao 
retornarmos recurso com 7 operações V’s, temos -11 + 7 = -4, ​logo temos 4 processos 
aguardando recurso.  
 

Comunicação Inter-processos 

 
1. Bind → Associa o socket ao endereço local, isso seria o bind em si, é usado para que o 
cliente possa se conectar no servidor usando o endereço local. É utilizado no Server 
side. É usada tanto em UDP quanto em TCP. 
 
Connect → É a primitiva que conecta a um endereço remoto(servidor), logo, é utilizado 
pelo Client. É usada somente em TCP, UDP simplWRRWesmente envia por sendto. 
 

 
  

2.  
a. At-most-once(no máximo uma vez) 
 
 
 
 
b. At-least-once(pelo menos uma vez) 

 
 c. Exactly-once(somente uma vez) 

 
 
 
 
 
 
 
 
 
 
 

 
3. O RMI Registry é um serviço de nomeação, o rmiserver usa o rmiregistry para fazer
um bind de um objeto remoto em java com os nomes, para que o cliente possa
tratar diretamente pelo nome registrado no rmiregistry e executar os métodos destes
objetos.

RMI cria um proxy remoto para este objeto e envia para os clientes, este objeto de
proxy, contém a referência para um objeto.
  
 

 
 
CAIU NA PROVA 2017/1 (com outros valores) 
4. i) Cada requisição do cliente: 4ms + 1ms (send) + 0,5ms (marshalling) + 
4ms(transmissão do request) + 1ms (receive) + 0,5ms (unmarshalling) = 11ms 
Cada resposta do servidor: 12ms (processar) + 1ms(receive) + 0,5 (unmarshalling) + 
4ms (transmissão da resposta) + 1ms (send) + 0,5ms (marshalling) = 19ms 
Como são duas requisições, 2 * 11 + 2 * 19 = 60 
 
ii) marshall + send + transmissão + unmarshall + servidor + marshall + transmissão + receive + 
unmarshall + cliente = 24ms, 2*24 = 48 
 
 
Se considerar a fluxo da seguinte forma: 
cliente marsh send ----- trans​ ----- r​ eceive unmarsh servidor marsh send​ ---- t​ rans ---- receive unmarsh 
i) soma cada valor individual * numero de requisições 
ii) (soma a parte azul * requisições) + soma parte rosa apenas uma vez* 
  * uma pq ta tudo concorrente no cliente 
 
 
 
 

Provas anteriores  
Prova 2016 (folder P1/2016) 
Questão 1​: Qual é a saída do programa abaixo, impressa na “Linha C” e na “Linha D”? 

 
 
Linha C:​ PARENT: value = 20 (value = 17+3 -> valor obtido pela execução da thread) 
Linha D: ​CHILD: value = 3 
(compilei e testei) 
 Pthread_create, recebe 4 parâmetros, sendo o 3 e o 4 uma função de inicio e seus 
parâmetros respectivamente. 
 
 
Questão 2​: Considere a notação co-oc para especificação de programas concorrentes, e a 
primitiva <await(B) S;>, onde B é uma expressão booleana e S é uma sequência de 0 ou mais 
comandos. Dado o conjunto de comandos abaixo: 
C1: x = x - y² 
C2: y = y + x 
Para cada um dos casos abaixo, assuma x = 3 e y =2 inicialmente. Quais são os valores finais 
para x e y? 
i. C1;C2; 
Único valor possível: x = -1 e y = 1, pois não há concorrência. 
ii. co <C1;> // <C2;> oc 
Duas sequências possíveis de execução: 
C1C2: x = -1 e y = 1 
C2C1: x = -22 e y = 5 
iii. co <await(y >= x) C1;> // <C2;> oc 
Lado esquerdo tranca pois y = 2 < x = 3. Logo, C2 executa antes. 
C2 -> y = 5, x = 3. -> y > x! C1 desbloqueia. 
C1 -> x = -22. 
Valores finais: x = -22, y = 5. 
 
Questão 3:​ Compare os mecanismos de comunicação Pipes Unix, Sockets UNIX e Sun RPC. 
Compare as características e funcionalidades apresentadas por cada um deles. Em quais 
situações cada um dos mecanismos é apropriado? 
Sockets : É
​ local ou remoto, permite comunicação bidirecional, tem suporte a diferentes tipos 
de protocolos, flexibilidade (TCP/UDP) 
Pipes​: F
​ luxo de dados unidirecional, operar processos relacionados, apenas comunicação local 
Sun RPC:​ É implementação de alto nível, semântica at-least-once, binding local, apropriado para 
chamada de procedimento remoto. 
 
Questão 4​: Qual a finalidade das variáveis tipo lock(mutex), semáforos e monitores? Porque 
existem esses diferentes mecanismos? O que difere um do outro? 
Diferenças e Conceito 
a. Mutex 
i. Mutex deixam somente uma thread por vez entrar na seção crítica e 
somente essa thread pode liberar o mutex. 
 
No semáforo, pode ser sinalizado de qualquer outra thread ou processo a 
liberação. Por esse motivo semáforos são mais adequados para 
problemas de sincronização como produtor-consumidor. 
 
O mesmo mutex pode ser compartilhado entre vários processos, 
consequentemente várias threads entre esses processos. 
 
b. Semáforos 
i. O semáforo faz o mesmo com o mutex com a diferença de que podem 
entrar X processos dentro dessa seção crítica. 
 
Assim como mutex, podem ser utilizados por vários processo e threads, 
lembrando que os semáforos podem liberar ou alocar recursos de 
qualquer outra thread/processo. 
 
c. Monitores 
i. Monitores, assim como mutex só deixam uma thread/processo executar 
a seção crítica, são feitos para multi-thread dentro de um único processo. 
 
CAIU NA PROVA 2017/1 (com outros valores) 
Questão 5​: Uma variável s, do tipo semáforo, é inicializada em 2. Em seguida, onze operações 
P(s) e sete operações V(s) são realizadas por processos distintos. Ao final, qual é a quantidade 
de processos que estão esperando neste semáforo? 
Semáforo iniciado em 2; 
Cada operação P tira 1; 
Cada Operação V soma 1; 
 
Ao executar 11x a operação P, temos 2 -11 = -9. 
Ao executar em 7x a operação V, temos -9 + 7 = -2. 
 
Logo temos 2 processos esperando o semáforo. 
 
CAIU NA PROVA 2017/1 
Questão 6​: Com relação a comunicação inter-processos por troca de mensagens, analise as 
afirmativas abaixo: 
 i) Comunicação síncrona acontece somente quando ambas as primitivas send e receive 
tem semânticas bloqueantes. 
ii) Sockets fornece um modelo de comunicação com nomeação direta. 
iii) Recebimento bloqueante implica que o processo que faz o receive irá bloquear até 
que a mensagem seja transferida do buffer para o processo, ou retornará NULL caso não haja 
mensagens no buffer. 
a) Apenas I 
b) Apenas I e II 
c) Apenas I e III 
d) Apenas II e III 
e) I, II e III 
 
CAIU NA PROVA 2017/1 
Questão 7: A
​ ssinale a alternativa ​INCORRETA​: 
a) Semáforos podem ser usados para sincronização de condição, exclusão mútua e 
alocação de recursos. 
b) Uma aplicação contém uma condição de corrida somente quando o sistema 
operacional que executa esta aplicação tiver mais de um processador. 
c) Um semáforo binário é um tipo especial de semáforo usado para implementar exclusão 
mútua. Para este fim, ele é inicializado em 1 e só pode assumir valores 0 e 1. 
d) Um Monitor é uma construção que oferece duas facilidades: acesso em exclusão mútua 
para dados compartilhados e sincronização de condição entre processos através da 
primitiva wait e signal. 
e) Sincronização de condição permite garantir que processos executarão suas ações em 
uma determinada ordem, independentemente do escalonamento. 
 
CAIU NA PROVA 2017/1 (IGUAL) 
Questão 8:​ Assuma um processo cliente que faz chamadas remotas de procedimento(RPC) em 
um servidor que está em uma máquina remota. O cliente leva 6 ms para computar os 
argumentos que serão enviados para cada requisição, e o servidor leva 12 ms para processar 
cada requisição. O tempo de processamento do sistema operacional para executar cada send() 
ou receive() é 0,5 ms, e o tempo para transmissão para rede de cada mensagem de requisição 
ou resposta é 3 ms. A execução dos procedimentos marshalling ou unmarshalling leva 1,5 ms 
por mensagem. 
Suponha que tanto o processo cliente quanto o processo servidor estejam executando 
em uma máquina com um único processador, e que o tempo necessário para trocas de 
contexto(context switch) possa ser ignorado. Calcule o tempo levado pelo cliente para gerar e 
receber resultado de duas requisições: 
 
 (i) Se o cliente for implementado com uma única thread. 
(ii) Se o cliente tiver duas threads que possam fazer requisições concorrentemente. 
(i) Resposta: 
Cliente trabalhando(envio): 
Trabalho da requisição do cliente + marshalling + send() + transmissão 
6 + 1,5 + 3 + 0,5 = 11 
 
Servidor trabalhando(recebimento e envio): 
receive() + unmarshalling + trabalho na requisição recebida do cliente + marshalling + send() + 
transmissão 
0,5 + 1,5 + 12 + 1,5 + 0,5 + 3 = 19 
 
Cliente trabalhando(recebimento): 
receive() + unmarshalling 
0,5 + 1,5 = 2 
 
2 + 11 + 19 = 32ms x ​ 2 ​= 64ms 
 
(ii) Resposta: 
Cliente trabalhando(envio total do cliente): 
Trabalho da requisição pelo cliente + marshalling + transmissão + send() 
6 + 1,5 + 3 + 0,5 = 11 
Servidor trabalhando: 
receive() + unmarshalling + trabalho da primeira requisição pelo servidor + marshalling + send()  
0,5 + 1,5 + 12 + 1,5 + 0,5 = 16 
receive() + unmarshalling + trabalho da segunda requisição pelo servidor + marshalling + send() 
+ transmissão 
0,5 + 1,5 + 12 + 1,5 + 0,5 + 3 = 19 
Cliente trabalhando(aqui só contamos o último recebimento pois o primeiro enquanto o 
servidor trabalhava foi feito): 
receive() + unmarshalling 
0,5 + 1,5 = 2 
 
2 + 16 + 19 + 11 = 48ms   
 
 
 
 
 
 Questão 9: I​ mplemente usando pseudo-linguagem, um monitor que emule a funcionalidade de 
um semáforo. O monitor deve obrigatoriamente implementar os procedimentos SemaphoreP() 
e SemaphoreV(). Assuma existência de um tipo de dado COND, usado para declarar variável de 
condição. 
 
(tem nos slides de monitor isso) 

monitor Semaphore {
​int​ s = ​1​; ​# s >= 0
cond pos; ​# signaled when s > 0
procedure ​Psem​() {
​while​ (s == ​0​)
wait(pos);
s = s – ​1​;
}
procedure ​Vsem​() {
s = s + ​1​;
signal(pos);
}
} 
 
 
Prova 1 - 2014 
CAIU NA PROVA 2017/1 
Questão 1: C ​ onsiderando a implementação de monitores, explique as diferenças entre as 
estratégias de sinalização “signal-and-continue”(SC) e “signal-and-wait”(SW). Em particular, 
explique o que acontece com o processo sinalizador e com o processo sinalizado em cada uma 
das estratégias. 
 
1) Dentre as duas estratégias de sinalização, existe uma diferença básica em relação ao 
processo sinalizador e sinalizado: 
a) Em SC -> Não-preemptiva -> O processo sinalizador continua sua execução e o sinalizado 
passa para a fila do monitor. Estratégia predominante em Java, ambientes Unix e pthreads. 
b) Em SW -> Preemptiva -> O processo sinalizador vai para a fila da entrada do monitor e o 
processo sinalizado inicia sua execução. 
 
c) Ainda existe SU (Signal and Urgent Wait) no qual o processo sinalizador vai para a frente da 
fila de entrada do monitor e o sinalizado inicia sua execução. 
 
Questão 2: R
​ epetida de 2016(3) 
 
CAIU NA PROVA 2017/1 
Questão 3: S
​ ervidores podem ser construídos de forma a limitar o número de conexões 
abertas. Por exemplo, um servidor pode desejar ter no máximo N conexões sockets abertas em 
um dado momento. Assim que N conexões forem estabelecidas, o servidor não irá aceitar 
qualquer nova conexão até que uma conexão existente seja liberada. Explique como semáforos 
podem ser usados pelo servidor para limitar o número de conexões concorrentes. 
Com um semáforo S inicializado em 100. Realiza uma operação P(S) cada vez que uma 
conexão for aberta e uma operação V(S) toda vez que uma conexão for fechada. 
 
CAIU NA PROVA 2017/1 (igual) 
Questão 4:​ Em sistema leitores-escritores com preferência para leitores, uma operação de 
leitura consome 3 unidades de tempo e uma operação de escrita consome 5 unidades de 
tempo. No instante ti -1 não há nenhum processo leitor, nem escritor. Um leitor chega no tempo 
ti, e cinco leitores e um escritor chegam no tempo ti+1. Se não chegar mais nenhum processo, 
qual instante de tempo o escritor terminará de escrever? 
 
a) ti+8 
b) ti+9 
c) ti+18 
d) ti+19 
e) ti+20 
 
Os leitores têm preferência e operações de escrita não podem ser feitas ao mesmo 
tempo em que alguma outra operação estiver sendo feita.  
Em ​ti​, chega o primeiro leitor, que ficará lendo até t​ i+3. ​No instante seguinte, ​t+1​, cinco 
leitores e um escritor chegam. Como operações de leitura podem ser feitas simultaneamente 
e os leitores têm preferência, eles já iniciam a leitura, e a terminam em t​ +4​. O escritor fica 
aguardando até que não haja algum leitor ou outro escritor executando. Portanto, em t​ +4​ o 
escritor passa a executar, e termina de escrever em ​t+9​. 
 
CAIU NA PROVA 2017/1 (igual) 
Questão 5: U
​ ma variável s, do tipo semáforo, é inicializada em 3. Doze operações P(s) e sete 
operações V(s) são realizadas por processos distintos. Qual é a quantidade de processos que 
estão esperando neste semáforo? (Conferida na prova) 
 
a) 5 
b) 4 
c) 3 
d) 2 
e) 1 
S = 3. 
Como P = tirar 1; 
E V = colocar 1; 
 
12x P = -12  
7x V = 7 
3 - 12 + 7 = -2, ​logo 2 processos estão aguardando. 
 
Questão 6: R ​ epetida da prova de 2016(7) 
 
CAIU NA PROVA 2017/1 
Questão 7:​ Nesta questão, assuma um modelo de falhas que considere APENAS perdas 
ocasionais de mensagens, duplicações de mensagens, e mensagens entregues fora de ordem. 
Assinale a alternativa CORRETA:(Conferida na prova) 
a) Nos modelos Sun RPC e Java RMI, o middleware/runtime implementa um protocolo da 
família request-reply com semântica at-least-once, garantindo assim que o 
procedimento ou método remoto será executado pelo menos uma vez (mas poderá ser 
executado mais vezes). 
b) Em RPC, parâmetros de entrada definidos na IDL podem ser passados por valor ou por 
referência, mas parâmetros de saída somente podem ser passados por valor. 
c) No modelo RMI, o componente dispatcher faz o marshalling dos argumentos de uma 
chamada no lado do cliente e despacha a chamada para o servidor remoto. 
d) A implementação do Sun RPC adota uma semântica at-least-once, e assume que as 
operações implementadas pelo servidor são idempotentes. 
e) No modelo RMI, o módulo de referência remota é responsável por traduzir referências 
locais para referências remotas, e por implementar um protocolo da família 
request-reply com uma determinada semântica. 
Questão 8: R
​ epetida Prova de 2016(6) 
 
CAIU NA PROVA 2017/1 
Questão 9:​ Qual é a saída do programa abaixo, impresso na “Linha A”?(Conferida na prova) 
 

#includes…

int​ value = ​5​;

int​ ​main​() {
pid_t​ pid = fork();
 if​ (pid < ​0​) {
printf(“Fork failed\n”);
return​ ​1​;
}
else​ ​if​ (pid == ​0​) {
value +=​15​;
return​ ​0​;
}
else​ {
wait(pid);
prinf(“PARENT: value = “%d\n”, value);​ ​/*LINHA A*/
​return​ ​0​;
}
} 
 
Pid == 0, processo filho.
Pid > 0, processo pai.

Logo o value ta sendo acrescido no processo filho e no else, o processo pai é impresso,
mas como tem a cópia de variáveis, não tem relação os 2 values, é impresso então o
valor 5, que é o valor inicial da variável value que não foi alterada no processo pai.

 
Questão 10: ​Assuma um processo cliente que faz chamadas remotas de procedimento(RPC) 
em um servidor que está em uma máquina remota. O cliente leva 5ms para computar os 
argumentos para cada requisição, e o servidor leva 10ms para processar cada requisição. O 
tempo de processamento do sistema operacional para executar cada send() ou receive() é 
0,5ms, e o tempo para transmissão na rede de cada mensagem de requisição ou resposta é 
3ms. A execução dos procedimentos de marshalling ou unmarshalling leva 0,5ms por 
mensagem. 
Suponha que o tempo necessário para trocas de contexto(context-switch) possa ser 
ignorado. Calcule o tempo levado pelo cliente para gerar e receber o resultado de duas 
requisições. 
 
(i) se o cliente for implementado com uma única thread. 
(ii) se o cliente tiver duas threads que possam fazer requisições concorrentemente em um 
único processador. 
  

 
 
CAIU NA PROVA 2017/1 (igual) 
Questão 11: ​Considere o programa abaixo, escrito em pseudo-linguagem. O programa deve 
implementar corretamente o acesso a um buffer limitado de 10 posições, utilizando monitores 
e variáveis de condição(cheio e vazio). Complete as lacunas para garantir o acesso 
sincronizado de produtores/consumidores ao buffer compartilhado. Importante considere que 
o monitor implementa a semântica “signal-and-continue”(SC). 
 
 

monitor Buffer{
typeT buf[n];
int​ inicio = ​0​, fim = ​0​, cont = ​0​, n = ​10​;
cond cheio,
 vazio;
procedure ​coloca​(typeT dado) {
ESPAÇO A
buf[fim] = dado; fim = (fim+​1​) % n; cont++;
ESPAÇO B
}
procedure ​retira​(typeT &resultado) {
​ESPAÇO C
resultado = buf[inicio]; inicio = (inicio+​1​) % n; cont--;
ESPAÇO D
}
} 
 
ESPAÇO A​ = while(cont == n) wait(cheio); 
ESPAÇO B​ = signal (vazio); 
ESPAÇO C​ = while (cont == 0) wait (vazio); 
ESPAÇO D​ = signal (cheio); 
 
Prova 1 - 2013 
 
Questão 1​: Dentre as afirmações abaixo, assinale quais são verdadeiras (V) e quais são falsas 
(F). 
(​ ​F​ ) Toda solução para exclusão mútua necessita de operações Test And Set implementadas 
pelo hardware (processador) 
( ​V​ ) Um grafo de fluxo de processos que não é propriamente aninhado pode ser implementado 
em C sobre um sistema operacional UNIX utilizando as chamadas fork, quit e join 
( ​F​ ) Programação concorrente somente confere maior velocidade ao programa quando se 
utilizam máquinas com múltiplos processadores, ou múltiplos cores 
( ​F​ )​ Um trecho de pseudo-código utilizando semáforos que faz: “while (condição) P();” é um 
exemplo típico de busy waiting, o que é fácil perceber pela construção “while”, que permanece 
continuamente testando a condição 
( ​F​ ) A vantagem de usar threads é que não é necessário empregar mecanismos de 
sincronização de controle e de acesso a dados, já que elas executam dentro de um processo. 
Como um processo só pode ser escalonado em um único processador (ou core), se elimina a 
concorrência. 
( ​F​ ) A inversão de prioridade é caracterizada por uma thread de menor prioridade ser 
escalonada antes de uma thread de maior prioridade quando as duas se encontram no estado 
apto (ready) 
( ​V​ ) A inversão de prioridade é caracterizada por uma thread de menor prioridade deter um 
recurso (lock de uma seção crítica) e assim impedir que uma thread de maior prioridade saia do 
estado bloqueado 
( ​V​ ) Espera ativa (busy waiting) é uma técnica em que um processo (ou thread) verifica 
continuamente uma condição até que ela seja verdadeira. 
( ​F​ ) Com relação a sockets, um programa UDP emprega a primitiva accept, enquanto um 
programa TCP emprega a primitiva connect 
( ​F​ )​ Em monitores, a estratégia de sinalização signal-and-continue implica que o processo 
sinalizado irá continuar sua execução no monitor a partir daquele momento, enquanto que o 
processo sinalizador irá para a fila de entrada. 
 
Questão 2:​ Repetida questão 4 da lista 
 
CAIU NA PROVA 2017/1 
Questão 3: C
​ om relação a mecanismos de comunicação entre processos, explique as 
diferenças entre os modelos de comunicação com memória compartilhada (shared-memory) e 
troca de mensagens (message passing). Quais são as vantagens e desvantagens de cada um? 
Troca de mensagens: 
Utilizada para pequenas quantidades de dados;  
Utiliza várias vezes chamadas do Kernel;  
Programação simples;  
Pode ser utilizada entre processos não-relacionados;  
Utilizada em programação distribuída 
 
Memória Compartilhada:  
Utilizada para grandes quantidades de dados; 
Chamadas do Kernel apenas para estabelecer a região da memória; 
Comunicação mais rápida e eficiente; 
Utilizada apenas entre processos relacionados; 
(Programação mais complexa? Tá meio riscado na prova.. Melhor confirmar) 
 
Questão 4:​ Repetida Prova 2014(4) 
 
 
Questão 5​: Utilizando um modelo de falhas que considere perdas ocasionais de mensagens, 
duplicações de mensagens e mensagens entregues fora de ordem, uma semântica no máximo 
uma vez (at-most-once) é caracterizada por: 
 a) Garantir que uma tarefa remota foi executada uma única vez retornando um resultado 
válido ou, em caso contrário, retornando um erro. 
b) Garantir que uma tarefa remota foi executada pelo menos uma vez, mas, eventualmente, 
ela pode ter sido realizada várias vezes antes de retornar um resultado válido. 
c) Executar a tarefa remota exatamente uma vez, mesmo na presença de falhas. 
d) Talvez ter sido executada uma vez. 
e) Executar a tarefa remota várias vezes, mas mantendo sempre o mesmo resultado final. 
 
Questão 6: A
​ ssinale a alternativa INCORRETA: 
a) Semáforos podem ser usados para sincronização de controle, exclusão mútua e 
alocação de recursos 
b) Uma aplicação contém uma condição de corrida do tipo ​data race​ somente quando o 
sistema computacional que executa esta aplicação tiver mais de um processador (ou 
core). 
c) Um semáforo binário é um tipo especial de semáforo usado para implementar exclusão 
mútua. Para esse fim, ele é inicializado em 1 e só pode assumir um de dois valores, zero 
ou um. 
d) Um monitor é uma construção que oferece duas facilidades: acesso em exclusão mútua 
para dados compartilhados e sincronização de controle entre processos através da 
primitivas wait e signal. 
e) Sincronização de controle é a garantia de que processos executarão suas ações em 
uma determinada ordem, independentemente do escalonamento. 
 
Questão 7​: Repetida da prova de 2014(7) 
 
Questão 8​: Repetida da prova de 2016(6) 
 
Questão 9: I​ gual a questão 2 da parte de primitivas de sincronização da Lista, apenas pede para 
preencher outra parte do código. 
 
Questão 10: ​Considere o pseudo-código abaixo, que consiste em uma tentativa de resolver o 
problema do jantar dos filósofos. Qual é o problema dessa solução? Apresente duas (2) formas 
de resolver o problema: explique o que deve ser feito e mostre as soluções em pseudo-código. 
 

N = 5
Var semaphore forks[N] = {1,1,1,1,1}
Process Philosopher [int i=0 to N-1] {
int left = i;
 right = (i+1) % N;
while (true) {
Think;
P(forks[left]);
P(forks[right]);
Eat;
V(forks[left]);
V(forks[right]);
}
} 

 
O problema é que todos os filósofos podem pegar o garfo à esquerda, e ficar esperando o garfo 
da direita, que nesse caso nunca será liberado. (DEADLOCK) 
 
Solução 1: 
Um filósofo pega o garfo da direita e depois o da esquerda, e os demais pegam primeiro da 
esquerda e depois o da direita 

…
while (true) {
Think;
if (i == 0){
P(forks[right]);
P(forks[left]);
} else {
P(forks[left]);
P(forks[right]);
}
Eat;
V(forks[left]);
V(forks[right]);
}
...

 
Solução 2: 
Se no máximo N-1 filósofos tentarem comer, haverá sempre um que terá a chance de pegar 
dois garfos. 
Deve ser feito utilizando um semáforo adicional para representar o número máximo de 
filósofos que terá a chance de pegar dois garfos.