Duvida Thread..outras tb?

2 respostas
P

Caros,

estou tentando fazer a classe para ver o resultado do teste abaixo
mas não estou conseguindo chegar ao resultado;

Given: t is a reference to a valid Thread object And the following valid run() method for t: 

 9.  public void run() {
10.    System.out.print("go ");
11.  }

And: 

18.  t.start();
19.  t.start();
20.  t.run();

Which can be a result?


A go
B go go
C go go go
D go followed by an exception
E go go followed by an exception
F An exception is thrown with no other output.

o que estou tentando fazer para chegar ao resultado

public class Test extends Thread {
	   public void run() {
	    System.out.print("go ");
	  }

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Test t = new Test();

		t.start();
	}

}

mais uma duvida abaixo resultado letra B

qdo criou o array a referencia do objeto ficou do Bird e do Parrots

e na hora do for da chamada talk foi pela referencia é isso ?

Given: 

 1. class Bird {
 2.   void talk() { System.out.print("chirp "); }
 3. }
 4. class Parrot2 extends Bird {
 5.   protected void talk() { System.out.print("hello "); }
 6.   public static void main(String [] args) {
 7.     Bird [] birds = {new Bird(), new Parrot2()};
 8.     for( Bird b : birds)
 9.       b.talk();
10.   }
11. }

What is the result?

A chirp chirp 
B chirp hello 
C hello hello 
D Compilation fails. 
E An exception is thrown at runtime.

mais uma duvida abaixo

no if é verdade qdo se faz t.add(“one”) essa minha duvida ???

class AddStuff {
	    public static void main(String [] args) {
	      TreeSet<String> t = new TreeSet<String>();
	      if(t.add("one "))
	        if(t.add("two "))
	          if(t.add("one "))
	            t.add("two ");
	     for(String s : t)
	       System.out.print(s);
	   }
	 }

no codigo abaixo o metodo compareTo para qualquer valor que adicione
na lista para objeto Stuff vai voltar 1 como resultado …???

class Stuff implements Comparable {
	    int x; 
	    Stuff(int x) { this.x = x; }
	    public int compareTo(Object o) { return 0; }
	  }
	  class AddStuff1 {
	    public static void main(String [] args) {
	      TreeSet<Stuff> ts = new TreeSet<Stuff>();
	     ts.add(new Stuff(1));
	     ts.add(new Stuff(2));
	     System.out.println(ts.size());
	 } }

2 Respostas

Richard_Mendes_Madur

Cara,
No Primeiro problema, também não consegui chegar a essa solução.
o método start() só pode executado uma única vez. Se o start() for executado novamente, ocorrerá uma exceção.
Por isso acho que a resposta seria a letra “D”, já que as execuções das linhas 18 e 19 são iguais.

Na segunda dúvida, ocorre o seguinte:
O array possui referência para objetos do tipo “Bird”. Isso que dizer que apenas os métodos existentes
na classe Bird estarão acessíveis explicitamente. Porém, se o método for subscrito, automaticamente este é que será executado.
Assim:

for(Birds b: birds){
	b.talk();
}

O código anterior irá executar o método talk() duas vezes.
Na primeira vez, executa o método talk do objeto Bird e na segunda executa o método talk() do objeto Parrot2.
Se o método não fosse subscrito na classe Parrot2, o resultado seria letra “A”.

Na dúvida do t.add(“one”) ocorre o seguinte:
O Objeto é um TreeSet e este objeto não permite inserir objetos iguais. o método add() retorna true quando o objeto a ser inserido não está presente no TreeSet.
Assim, na primeira linha, como foi a primeira vez que você inseriu um objeto, o retorno é true, já que o objeto pode ser inserido.
No segundo if ocorre a mesma coisa, já que o objeto a inserido é diferente do primeiro. Nos ifs seguintes, o retorno é false e o objeto não é inserido
na arvore porque esses objetos já existem. Logo ficam apenas dois objetos na árvore. o “one” e o “two”.

Na última dúvida, o problema é semelhante ao anterior.
O método compareTo() implementado sempre retorna 0, o que quer dizer que os objetos comparados serão SEMPRE iguais.
Assim, ao tentar inserir novamente qualquer o objeto (mesmo modificando o argumento do construtor),
o método compareTo vai dizer que eles são iguais e não deixará outro objeto ser inserido no TreeSet.

Acho que é isso (Se eu estiver enganado com alguma coisa, me desculpe)
Espero ter ajudado.

ViniGodoy

Na primeira são as letras D e F. Pode ser antes ou depois daquele GO, embora muito provavelemente ocorrerá mais casos da letra F.
O fato é que nunca podemos garantir em que ordem as threads rodam. Pode ser que logo depois do start() haja preempção e a segunda thread rode (o que é pouco provável, já que envolve o overhead de criar a thread e, enquanto isso pode haver uma preempção e gerar a exceção).

O segundo é é letra B mesmo. A confusão pode ocorrer no caso do segundo estar declarado como protected. Mas nesse caso é válido já que ele é menos restritivo do que o package private.

A terceira dúvida… Exceto no primeiro caso, os outros vão retornar 1. O TreeSet baseia-se no comparator, que nesse caso considera todos os objetos iguais.

Criado 6 de setembro de 2008
Ultima resposta 7 de set. de 2008
Respostas 2
Participantes 3