Thread extends duvida

camilolopes:

ae pessoal pq o codigo abaixo nao imprime nada se eu extends Thread agora se usar Runnable ele roda tranquilo...

class Exe1 implements Runnable{
	public void run(){
		for(int x=1; x<=100;x++){
			if(x%10==0){
				System.out.println("x " +Thread.currentThread().getName());
				
		try{
			Thread.sleep(1000L);
		}
		catch(InterruptedException a){}

		}
	}
	}
}
class Exe1Test{
	public static void main(String args[]){
		Exe1 e = new Exe1();
		Thread t = new Thread(e);
		Thread t1 = new Thread(e);
		t.setName("t");
		t1.setName("t1 ");
		t.start();
		
		t1.start();
		
	}
}

fiquei nessa duvida agora.. quem puder dar esse help ai.. agradeço!!

ae galera conseguir resolver tava criando o objeto errado.. hehe!

fiquei na duvida do meto yield(), a tentativa dele eh dar oportunidades a thread com o mesmo nivel de prioridade… ai la vai eu implementar uma simples class para tentar enteder… gostaria de saber de vcs se a class abaixo ta correto em relação ao uso do metodo yield()?

public class Ye implements Runnable{
	public void run(){
		for(int x=1;x<4;x++)
		System.out.println("yield - "  + Thread.currentThread().getName());
	}
}
class YeT{
	public static void main(String args[]){
		Ye y = new Ye();
		Thread t = new Thread(y);
		Thread t1 = new Thread(y);
		Thread t3 = new Thread(y);
		
		t3.setName("true");
		t.setName("defaul");
				
		t.yield();
		t1.yield();
		
		t.start();
		t1.start();
		t3.start();
	}
}

Valeu

O uso do Yield não está correto. Você está dando yield em Threads que nem sequer estão rodando…

Não confunda a variável que representa a Thread em execução com a Thread em si.

O uso correto do Yeld seria no seu Runnable:

public class Ye implements Runnable{ public void run(){ for(int x=1;x&lt4;x++) { System.out.println("yield - " + Thread.currentThread().getName()); Thread.yield(); } } }

Assim você está dizendo que o for pode ser interrompido por outras threads, pois o processamento dele não precisa ser contínuo. O yield era para ser usado em processamento muito pesado.

Entretanto, não é um método muito eficiente. Uma vez que você perdeu o controle de sua Thread, não se sabe em quanto tempo ela voltará a executar (ela pode mesmo ser a próxima e o yield não fazer efeito!) Se você quiser liberar o processamento da Thread, recomenda-se que você use Thread.sleep() no lugar. A vantagem do sleep é que você ainda pode dizer quanto tempo a Thread deve ficar dormente. Por exemplo:

public class Ye implements Runnable{ public void run(){ for(int x=1;x&lt4;x++) { System.out.println("yield - " + Thread.currentThread().getName()); Thread.sleep(5); //Pausa a Thread por 5 milis. } } }

é a kathy nao implementou esse metodo yield mais me diz ai ele tem q tá dentro do run()? da class que implementa runnable? pq o yield ele dar prioridade para uma thread com a mesma prioridade a executar no é isso?

O “yield” é equivalente a Thread.sleep(0).

É mais útil quando se usa uma implementação de Threads em um sistema operacional que não suporta threads - tal como o Windows 3.1 - 16 bits.

Num sistema desses, o Java só consegue alternar entre threads:

• Quando a thread efetua uma chamada ao sistema operacional (por exemplo, para acessar um arquivo, usar um socket, ou efetuar “sleep”);
• Ou quando você usa “yield”.

Isso, quando o programa chega na linha do Thread.yield(), ele pára e deixa outras Threads processarem.

O mesmo acontece com o sleep(), mas a Thread volta a entrar na fila depois do tempo especificado.

Mais para frente você ainda vai ver o wait, que dorme por um tempo especificado ou até que outra thread peça para ela acordar.

entao assim o sleep() eu tenho uma “certa segurança” que o thread vai voltar a executar apos o tempo ou ate antes o agendador que diz, o yield() vai lá saber se o thread atual ainda voltará a ser executado seria isso?
a minha maior dificuldade mesmo foi na implementação no yield().

É isso mesmo.

Como o “yield” é equivalente a “Thread.sleep(0)”, então se nenhuma outra thread tiver nada para fazer, ele retorna imediatamente e continua na mesma thread.
(Pode ser, por exemplo, que as outras threads estejam em “sleep” ou então estejam lendo arquivos do disco, e esperando que o disco mande os dados requisitados, ou estejam esperando dados chegar pela rede. )

po valeu galera… pela ajdua vou estudar suas implementações e partir para sicronização… me disseram q eh lenha!

Isso que o Thingol disse é bem verdade.

Por isso, se sua intenção for liberar o processador, use um sleep &gt 0. Assim, a Thread certamente irá dar uma "dormida".