Controle de Threads

Programação Java
#1

Ola Pessoal!

Como eu posso mudar(controlar) a priiridade das minhas Threads?

Desde já agradeço

#2 
nomedaThread.setPriority(x);

sendo x um valor de 1 a 10.

#3

Ola daniels, valeu pela ajuda, mas tenho o seguite código:

public static void main(String[] args) throws IOException, InterruptedException 
	{	
		ProgramaThread p = new ProgramaThread();
		p.setId(1);
		Thread t = new Thread(p);
		Informacao ppp = new Informacao();
		p.setId(2);
		Thread tt = new Thread(ppp);
		tt.setPriority(1);
		t.setPriority(2);
		t.start();
		tt.start();
	}

só que a prioridade não esta valendo, pois ainda as Threads estão aleatórias

como faço para executar primeiro tt.start() e depois t.start()?

Desde já agradeço

#4

Eu nunca mudei prioridade das Threads… Li muito pouco sobre Threads na verdade. Mas use o método sleep para forçar a execução de outra Thread.

public static void main(String[] args) throws Exception { ProgramaThread p = new ProgramaThread(); p.setId(1); Thread t = new Thread(p); Informacao ppp = new Informacao(); p.setId(2); Thread tt = new Thread(ppp); t.start(); t.sleep(100); tt.start(); tt.sleep(100); }

Como já disse, li pouco sobre isso e faz um tempo. Então não sei se está certo. Mas deve funcionar.

Outra coisa: eu mudei o throws ali para Excpetion, pois já que é a main, não há ninguém para tratar a exceção.

#5

Repita comigo: Eu não posso controlar a ordem do escalonador.

A prioridade só diz ao escalanador que vc precisa que a thread A rode mais ou menos que a B, mas não diz quando. E ele também não é obrigado a obedece-lo…

É uma péssima pratica tentar controlar o fluxo, especialmente mexendo nas prioridades. Aliás, a recomendaçao geral é que não se altere as prioridades das threads, pois nem todos os SOs podem garantir ausência de starvation (isto é, que threads de prioridades muito baixas, vão executar com certeza).

O máximo que uma thread pode fazer é se colocar para dormir (através de sleep ou wait) ou indicar que seria um bom momento para a preempção com yield(). Entretanto, a decisão final de trocar ou não de thread permanece com o escalonador, assim como a decisão de qual deve ser a próxima thread a processar.

Você só deve controlar a execução de threads em blocos onde há memória compartilhada. Isto é, quando duas threads percorrerem o mesmo objeto. Aí sim, você coloca os blocos sincronized, e impede que duas threads acessem o código ao mesmo tempo. Ainda assim, você não garante qual thread irá rodar aquele código por primeiro.

#6

Se você precisa que uma thread comece antes da outra, faça a primeira thread iniciar a segunda. Simples, não?

#7

E o código que eu postei não funciona. O sleep é dentro da Thread e não na main.

#8 
class Execucao1 implements Runnable {
    private Thread segunda;
    public Execucao1(Thread segunda) {
        this.segunda = segunda;
    }
    public void run () {
        System.out.println ("thread 1");
        segunda.start();
    }
}

class Execucao2 implements Runnable {
    public Execucao2() {
    }
    public void run () {
        System.out.println ("thread 2");
    }
}


class ThreadBemComportada {
    public static void main(String[] args) throws Exception {
        Thread thr2 = new Thread (new Execucao2());
        Thread thr1 = new Thread (new Execucao1 (thr2));
        System.out.println ("Iniciando a thread 1...");
        thr1.start();
        System.out.println ("Esperando a thread 1 voltar...");
        thr1.join();
        System.out.println ("Esperando a thread 2 voltar...");
        thr2.join();
        System.out.println ("Fim.");        
    }
}
#9