Thread -> não consigo por em ordem

Pra que você quer usar threads nesse caso?

porque o professor pedio

Você tem de usar “join”, não “synchronized”, para esperar uma thread acabar e iniciar a próxima.

Você não precisa usar nenhum “synchronized” nesse exemplo - acho que o problema que seu professor “pedio” está mal-formulado, já que normalmente eles pedem coisas mais úteis que sequenciar threads (nesse caso, você não precisa de threads).

Algo como:

Thread threadCarne = new Thread (new carne());
threadCarne.start(); // põe a carne...
threadCarne.join(); // e espera a carne ser posta
Thread threadPao = new Thread (new pao());
threadPao.start();
threadPao.join();

Note que não é “wait” nem “sleep”. O nome “wait” não quer dizer “esperar” no sentido que você quer, mas é muito específico para usar com “notify”.

Deu certo vlu…
porém vou ver agora se o professor vai aceitar desta forma (sem ser pelo synchronized)…
por isto ainda não vou fechar o tópico

Acho que seu professor quer que simule o join, usando “wait” e “notify”.
Eu em particular acho que usar “wait” e “notify” é igual a usar “goto”, ou seja, deveria ser proibido e apenas permitido para quem tivesse doutorado em ciências da computação.

Bom, eu não tenho doutorado em ciências da computação, portanto acho que eu não deveria estar usando wait e notify. Mas fica um exemplo para você ver como é que se usa o tal do synchronized (que acho que é muito complicado usar no seu caso em particular).

class TesteSequenciamentoThreads {
	private Thread criarThread (final String mensagem, final Object lock) {
		Thread thr = new Thread (new Runnable() {
			@Override
			public void run() {
				System.out.println (mensagem);
				synchronized (lock) {
					lock.notify();
				}
			}
		});
		return thr;
	}
	public void teste() {
		Thread t1, t2, t3, t4;
		Object lock = new Object(); // note que synchronized não deixa você usar "null"
		t4 = criarThread ("linha 4", lock);
		t3 = criarThread ("linha 3", lock);
		t2 = criarThread ("linha 2", lock);
		t1 = criarThread ("linha 1", lock);
		try {
			synchronized (lock) {
				t1.start();
				lock.wait();
				t2.start();
				lock.wait();
				t3.start();
				lock.wait();
				t4.start();
				lock.wait();
			}
		} catch (InterruptedException ex) {
			ex.printStackTrace();
		}
	}

    public static void main (String[] args) {
		TesteSequenciamentoThreads t = new TesteSequenciamentoThreads();
		t.teste();
	}
}

vlu ai pelo adicional…
o professor aceito o primeiro…

vlu pessoal

entanglement:

Acho que seu professor quer que simule o join, usando “wait” e “notify”.
Eu em particular acho que usar “wait” e “notify” é igual a usar “goto”, ou seja, deveria ser proibido e apenas permitido para quem tivesse doutorado em ciências da computação.

Nem tanto, usar wait() e notify() é o básico do básico de programação concorrrente. Porém eu concordo que é mais interessante usar a API de coleções concorrentes e pools de threads antes de sincronizar algo na mão.

Enfim, o pessoal não aprende PC justamente por causa de exemplos toscos com esse.