Threads

Amigo , do jeito que a classe Executa está, vc tem dois métodos com o mesmo nome (run()) e que recebem os mesmos argumentos (neste caso nenhum…)
Como vc espera que o Java saiba qual método chamar, já que a assinatura de ambos é identica?
Pelo que vi ele simplesmente chama o primeiro que encontra, que foi o que gerou a saida “Executa: run()”.

Quando vc chama o método start de uma Thread que recebeu no contrutor um objeto de uma classe que implementa a interface Runnable, a Thread chama o método run() deste objeto, exatamente como esta sua saída… Só que chamou o primeiro run de Executa, pois os dois são identicos em suas assinaturas, mesmo que o corpo do método seja diferente…

me diz ai onde tu conseguiu rodar isso, pq o compilador java não vai deixar compilar esse código com 2 metodos com a mesma assinatura.

Hehehe c conseguiu compilar isso?

Ele deixa compilar sim! é um caso de overridding, a implementação dos metodos é diferente, apesar da assinatura ser indentica…vou tentar compilar em casa…mas creio que dá para compilar sim…e o java vai rodar o primeiro metodo!

Ele deixa compilar sim! é um caso de overridding, a implementação dos metodos é diferente, apesar da assinatura ser indentica…vou tentar compilar em casa…mas creio que dá para compilar sim…e o java vai rodar o primeiro metodo!

Overriding? Ta certo, ta sobrescrevendo (implementando) o método da interface Runnable, mas o cabeçalho do método é public void run() num é? Ele tem DOIS métodos com a mesma lista de argumentos (nenhuma no caso). Isso não é permitido!!!

E outra, o kra ta sobrescrevendo o método start() da classe Thread! Isso num deve ser feito!!! Ele perde a funcionalidade da thread ao fazer isso! O método start que invoca o método run… O método start num deve ser sobrescrito.

AlunoJava, olha seu código correto:

public  class Teste {
	
	public static void main ( String[] args ) {
		
		MinhaThread mt = new MinhaThread( );
		Executa ex = new Executa();
		Thread th = new Thread(ex);
		mt.start();
		th.start();
		
	}
}

class MinhaThread extends Thread {
	
	public void run() {
		
		System.out.println("MinhaThread: run()" );
		
	}	
	
}

class Executa implements Runnable {
	
	public void run() {
		
		System.out.println("Executa: run()" );
		
	}
	
}

Então vc pergunta, pq quando eu executo meu aplicativo ele me fornece a saída:
MinhaThread: run()
Executa: run()

Ou mesmo (pode acontecer :D, lembre-se a JVM num garante a Thread q será iniciada primeiro...
Executa: run()
MinhaThread: run()

Meu deus, eu chamo o método start e naum o método run! E ele me mostra o resultado do método run!!! O que está acontecendo? Minha JVM está maluca?

NÃO! Não está maluca!
Quando vc usa threads vc sempre vai sobrescrever (de uma Thread) ou implementar (sobrescrever, eu sei :D) (da Runnable) o método run() que conterá o que a thred deve fazer, mas sempre ao instanciar uma thread vc vai usar o método start para iniciar sua execução. Vc NÃO deve sobrescrever o método start, ele já está implementado na thread e sua implementação faz com que o método run seja executado corretamente.

Entendeu? Espero que sim!

Falow!

Pessoal, foi mal. Foi erro de digitacao. Na classe executa o metodo é “public void start ( )” e nao “public void run( )”.
Por isso é que nao estava compilando.

Class MinhaThread extends Thread {

         public void run ( ) {
                System.out.println("MinhaThread: run ( )" );
         }	

         public void start ( ) {
                System.out.println("MinhaThread: start ( )" );
         }
}

Class Executa implements Runnable {

        public void run ( ) {
                System.out.println("Executa: run ( )" );
         }
	
       public void start ( ) {
                System.out.println("Executa: start ( )" );
         }
}

public  class Teste {
       public void static void main (   String args[ ] ) {

            MinhaThread mt = new MinhaThread( );
            Executa          ex = new Executa( );
            Thread            th = new Thread (ex);
            
            mt.start ( );
            th.start ( );
      }
}

Agora ficou tudo claro!! código resolvido!
realmente não compila da maneira que estava escrito…na hora que li fiquei em dúvida…mas realmente, dois metodos com mesma assinatura não caracteriza um overriding…o compilador não tem como saber qual metodo está sendo chamado…

Mas, akumaldo, ainda nao entendi direito porque ele imprimi “Minha thread:start( )” seguido de “Executa:run( )” ???

vamos por partes…

mt.start ();

como vc sobrescreveu o metodo start de thread, ele vai chamar o seu metodo que vai imprimir Minha Thread: start

th.start();

aqui, como vc mandou um Runnable para Thread, ele vai executar o run do Runnable, imprimindo Executa: run ( ) (assincronamente, mas nesse caso nao vai fazer diferenca)

qual a sua duvida ?

Deixa ver se eu entendi, takeshi10.
Se nao tivesse o metodo “public void start ( )” ele executaria o metodo public void run ( ) da classe “MinhaThread”, é isso mesmo?
Mas a funcao do start nao é registrar a thread no ambiente de execucao?
Tem um porque da sobrescricao?

Obrigado

AlunoJava:

Deixa ver se eu entendi, takeshi10.
Se nao tivesse o metodo “public void start ( )” ele executaria o metodo public void run ( ) da classe “MinhaThread”, é isso mesmo?
Mas a funcao do start nao é registrar a thread no ambiente de execucao?
Tem um porque da sobrescricao?

Obrigado

sim… o comportamento padrao do start () da classe Thread eh (criar uma nova thread e nela) executar o run() dele mesmo ou do Runnable que vc passou como parametro…
porque da sobrescricao eh vc que tem que dar pq o exemplo foi seu…

Esse exemplo nao é meu nao. Esse exercicio é de um concurso do TJ.
Mas, obrigado pela esclarecimento!