Thread wait e notifyAll - Duvida

Duvida,

A threadC não continua, não recebe o notifyAll da ThreadA.

Sabem o motivo?

Vlw

JavaChild Membro desde: 28/03/2010 00:21:08 Mensagens: 128 Offline

Acho que é porque o contexto da sincronização na main Thread está no objeto b. Logo, o notifyAll irá propagar apenas para a Thread b, pos a Thread c está sincronizando para si mesmo.

GUJ Master Membro desde: 01/07/2008 20:59:17 Mensagens: 1055 Offline

yastorm wrote:Acho que é porque o contexto da sincronização na main Thread está no objeto b. Logo, o notifyAll irá propagar apenas para a Thread b, pos a Thread c está sincronizando para si mesmo.

Exatamente. O Notify (ou notifyAll, como neste caso) "notifica" somente a(s) thread(s) que estiverem aguardando no objeto em que você chama o notify (ou notifyAll).

A Thread C ficará aguardando eternamente, já que você nunca chama notify no objeto que representa a thread C, que por acaso é o objeto em que ela espera.

Entendi, nesse caso , basta eu colocar um notify para C tambem.

O que eu queria é ver o notifyAll propagando a liberação de mais thread, alguem sabe como fazer isso no exemplo?

GUJ Master Membro desde: 01/07/2008 20:59:17 Mensagens: 1055 Offline

Você pode, por exemplo, criar um objeto no metodo main, e passar ele para ambas as threads, B e C, via construtor, e fazê-lar dar wait neste objeto. Assim no main, você dá um notifyAll neste objeto e ambas as threads B e C serão afetadas. Só tome cuidado que seu código é arriscado: Main pode invocar notifyALL antes que uma das threads B ou C, ou até mesmo as duas tenham invocado wait. Neste caso as duas ficaram aguardando para sempre.

This message was edited 3 times. Last update was at 13/06/2010 15:45:37

rod.attack wrote:Você pode, por exemplo, criar um objeto no metodo main, e passar ele para ambas as threads, B e C....

JavaChild Membro desde: 28/03/2010 00:21:08 Mensagens: 128 Offline

Acho que você não entendeu o que o amigo quis dizer. As três Threads precisam ter um objeto em comum. As Thread b e c não fazem ideia de que a Thread a existe.

Olhe abaixo:

Olhe esse exemplo que tirei do livro da Kathy. Os objetos Reader tem um objeto Calculator em comum. Esse é o elo de ligação entre o notify.

yastorm wrote:Acho que você não entendeu o que o amigo quis dizer. As três Threads precisam ter um objeto em comum. As Thread b e c não fazem ideia de que a Thread a existe.

Olhe abaixo:
public void run() { synchronized (this) { for (int i = 0; i < 100; i++) { total += i; } //notifyAll(); } } }

Olhe esse exemplo que tirei do livro da Kathy. Os objetos Reader tem um objeto Calculator em comum. Esse é o elo de ligação entre o notify.

Eu tinha visto esse exemplo e o que pegou dele é, com ou sem o notifyAll o resultado é o mesmo.

Estou boiando nesse notifyAll

Ninguem? Hehehe

GUJ Hacker Membro desde: 26/09/2009 09:18:56 Mensagens: 5750 Offline

Rode o programa abaixo e veja por que talvez você esteja tendo problemas.

De modo geral, wait + notify é a mesma coisa que goto para threads; é uma forma muito básica e muito difícil de usar. Se precisar de sincronização entre threads, use alguma classe de java.util.concurrent.

package guj;

class Thread1 implements Runnable {
	public Thread1 (Object lock) { this.lock = lock; }
	@Override
	public void run() {
		System.out.println ("Thread 1 está esperando...");
		synchronized (lock) {
			try {
				lock.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println ("Thread 1 foi acordada");
	}
	private Object lock;
}
class Thread2 implements Runnable {
	public Thread2 (Object lock) { this.lock = lock; }
	@Override
	public void run() {
		System.out.println ("Thread 2 está esperando...");
		synchronized (lock) {
			try {
				lock.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println ("Thread 2 foi acordada");
	}
	private Object lock;
}
class Thread3 implements Runnable {
	public Thread3 (Object lock) { this.lock = lock; }
	@Override
	public void run() {
		System.out.println ("Thread 3 está esperando...");
		synchronized (lock) {
			try {
				lock.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println ("Thread 3 foi acordada");
	}
	private Object lock;
}

public class TesteNotifyAll {
	public static void main (String[] args) {
		Object lock = new Object();
		Thread thr1 = new Thread (new Thread1(lock));
		Thread thr2 = new Thread (new Thread2(lock));
		Thread thr3 = new Thread (new Thread3(lock));
		thr1.start();
		thr2.start();
		thr3.start();
		// Note que aqui estou dando tempo suficiente para todas as threads iniciarem.
		// Você não pode acordar uma thread (que está em wait) se ela ainda não chegou 
		// no wait! Pode ser isso que deu problema no seu programa. 
		// E é por isso que é extremamente difícil trabalhar com threads usando só wait e
		// notify. Prefira usar as classes de java.util.concurrent.
		try { Thread.sleep (2000); } catch (InterruptedException ex) {}
		System.out.println ("Acordando uma ou mais threads");
		synchronized (lock) {
			lock.notifyAll();
		}
		try { thr1.join(); } catch (InterruptedException ex) {}
		try { thr2.join(); } catch (InterruptedException ex) {}
		try { thr3.join(); } catch (InterruptedException ex) {}
	}
}

Notícias, artigos e o maior fórum brasileiro sobre Java