Exercícios sobre threads

1. Escreva a classe PrimeiroExemplo:

public class PrimeiroExemplo implements Runnable {

private int identificador; // fazer o getter e setter para o
atributo identificador
public void run () {
for (int ind = 0; ind<10000; ind++) {
Sistem.out.println(“PrimeiroExemplo” + "
identificador " + ”com valor” + ind);
}
}
}

Escreva a classe de Teste

public class Teste {
public static void main(String args[]) {
PrimeiroExemplo p1 = new PrimeiroExemplo();
p1.setIdentificador(1);
Thread t1 = new Thread(p1);
t1.start();
PrimeiroExemplo p2 = new PrimeiroExemplo();
p2.setIdentificador (2);
Thread t2 = new Thread(p2);
t2.start();
}
}
Rode o programa algumas vezes e veja que as respostas aparecem em ordem diferente.

2. Exercício: considere um simulador de corridas de fórmula 1 que simula uma disputa entre dois
pilotos: Rubinho e Massa.

•Cada carro funciona de forma independente;
•O tempo de cada volta é dado por um valor randômico (0 a 1000ms), e o programa deve esperar
por este tempo sem fazer nada para então iniciar a próxima volta;
•Ao final da corrida (quando os dois carros completam 10 voltas): o simulador mostra o tempo
acumulado para cada um dos pilotos e aponta o vencedor ou empate.

3. Implemente uma classe que implemente a classe Runnable e possua o atributo estático do tipo
inteiro com identificador valor. O método run deve conter um laço que deve executar 100 vezes, a
cada interação realizar a impressão do identificador da thread e valor, incrementar o atributo a valor
em uma unidade e ao final imprimir o identificador da thread e valor novamente. Crie uma classe de
teste que e crie um objeto da classe criada e dispare duas threads passando este objeto. Observe o
resultado obtido.

4. A partir a implementação do exercício anterior sincronize o acesso ao atributo valor garantindo

que apenas uma thread acesse-o por vez.

5. Implemente uma caixa onde um inteiro pode ser armazenado. Se uma thread tentar armazenar um
inteiro em uma caixa cheia ela será suspensa até que alguma thread retire o inteiro da caixa. Do
mesmo modo, se uma thread tentar retirar um inteiro de uma caixa vazia ela será suspensa até que
uma outra thread coloque um inteiro na caixa. Esse é um exemplo do problema do
produtor/consumidor.