- Crie um programa que cria 10 threads cada uma escreve uma mensagem na tela contendo seu número.
- Escreva um programa que realize o cálculo das somas dos valores das
linhas de uma matriz qualquer de números inteiros e imprima o
resultado na tela. Faça com que o cálculo do somatório de cada linha
seja realizado em paralelo por uma thread.
- Defina a classe Contador como uma implementação da interface Runnable,
que imprime números de 0 a 1000. Crie a classe TesteContador que deve
definir o método main que cria e inicia a execução do thread Contador.
Teste o resultado executando a classe TesteContador. Agora altere o
método main da classe TesteContador para criar dois ou mais threads
Contador e inicialize a execução dos mesmos.
- Crie uma classe T1 do tipo Thread com um método construtor que
receba um número de identificação da Thread e um método run que fique
em loop eterno imprimindo na tela a frase "Thread x executando", onde x
é o número de identificação da Thread. Faça um programa que crie uma
matriz de 5 Threads T1 e, com um laço FOR, inicialize todas as Threads.
- Crie duas threads onde uma fica enviando notícias a cada 5 segundos (textos quaisquer, no total de 10), enquanto a outra fica enviando a hora a cada 10 segundos. A hora deverá ser informada umas 5 vezes para que o programa se encerre.
- Crie um programa que cria 3 threads.A primeira escreve na tela “A”, a
segunda “B” e a terceira “C”. Faça que seja sempre escrito na tela
“ABC”.
- Escreva um programa em que duas threads escrevam números aleatórios em um vetor global de inteiros e de tamanho 100. Estas threads devem usar mutexes para obter o valor que indica a posição a ser preenchida no vetor. Este valor começa em -1 e cada thread deve incrementá-lo antes de usá-lo. Quando o vetor estiver preenchido a thread original deve ser acordada por meio de uma variável de condição.
- Defina uma classe Mailbox que tem um atributo message do tipo String. A classe Mailbox deve ter dois métodos: storeMessage e retrieveMessage. O método storeMessage recebe um String e, se o mesmo tiver sido consumido (message == null), armazena no atributo message do Mailbox. Caso contrário, quem chamou o método storeMessage deve esperar até que alguém consuma a mensagem (chamando o método retrieveMessage). De forma similar, o método retrieveMessage retorna o valor da mensagem, caso ela tenha sido produzida/armazenada (message != null). Caso contrário quem chamou o método deve esperar até que alguém produza uma mensagem (chamando o método storeMessage).
- Crie a classe Producer, que é um thread e deve ter um atributo do tipo
Mailbox e no seu método run deve ser definido um loop que executa o
método storeMessage do Mailbox, armazenando mensagens no Mailbox.
- Defina um a classe Consumer, que também é um thread, e que deve consumir mensagens (chamando o método retrieveMessage) escritas em no seu atributo do tipo Mailbox.
- Crie uma classe de teste com um método main que cria um Producer e um Consumer que compartilham o mesmo Mailbox e iniciam a execução.
- Altere a classe de teste para criar mais de um produtor e/ou consumidor para o mesmo Mailbox.
Dicas:
- Utilize os métodos wait e notifiAll para implementar os métodos da classe Mailbox.
- Na última parte do exercício, onde é pedido para alterar a classe de teste, você deve adicionar um atributo de identificação (String) nas classes
Producer e Consumer, de modo a permitir que sejam identificados tanto que está consumindo uma mensagem, quanto que esta produzindo a mesma. Para tal concatene o identificador dos objetos a mensagem a ser enviada (no caso do produtor) ou a mensagem a ser impressa (no caso do consumidor). - O programa ExThreadsABC.java
ilustra o uso de threads em Java. Esse programa não controla o acesso
concorrente aos dados compartilhados. Para verificar o que pode dar
errado, compile esse programa e execute-o diversas vezes, comparando os
resultados das diferentes execuções.
- Corrija o programa do exercício anterior, usando um método
synchronized. - Escreva uma classe que permita paralelizar uma pesquisa em um array de inteiros. Isso deve ser feito com o seguinte método: public static int parallelSearch(int x, int[] A, int numThreads). Este método cria tantas threads quanto especificadas em numThreads, divide o array A em muitas partes e dá a cada thread parte do array para procurar sequencialmente pelo valor x. Se uma thread encontrar o valor x, então é retornado o índice i (A[i]=x), ao contrário -1.
- Analise a classe SimplePingPong.java, que ilustra o uso dos métodos wait() e notifyAll().
- Obtenha a classe FlightSimulator.java.
Este programa possui 2 threads que simulam um avião e um aeroporto. O
avião deve sincronizar-se com o aeroporto para verificar se há pista
livre para decolagem ou aterrissagem. Para isso, você deve implementar
o método waitAvailableRunway() da classe Airport.
- O programa FlightSimulator.java
tem uma thread que executa indefinidamente (aeroporto). Altere o
programa para que esta thread termine depois que o avião aterrissar
(use alguma forma de interação entre threads).
- O programa FlightSimulator.java
usa uma forma alternativa de especificar o trabalho que será executado
pelas threads: herança da interface Runnable. Reescreva o programa
usando herança da classe Thread, como no programa SimplePingPong.java.
- Cinco lebres disputarão uma corrida. Cada lebre pode dar um salto que varia de 1 a 3 metros de distância. A distancia percorrida é de 20 metros. Na corrida, cada lebre dará um salto, informar quantos metros ela pulou a cada salto realizado. Em seguida, a lebre pára para descansar (yield()). Escreva um programa, utilizando threads (uma para cada lebre), que informe a lebre vencedora e a colocação de cada uma delas no final da corrida. Informar também quantos pulos cada uma delas deu.
|
ď Edemberg Rocha, 19/03/2009 08:53 ď FlightSimulator.java (3k) Edemberg Rocha, 19/03/2009 08:57 ď Edemberg Rocha, 19/03/2009 08:57
|