Hola:
El problema con el primer código está en que dentro del run() de Reader
asume q el thread de Calculator no ha terminado. Lo cual, como bien dices, es un error. Si el thread de Calculator ya terminó el wait va a esperar eternamente.
El resultado q quieres obtener lo puedes hacer usando Futures, Callables y Executors.
Si te interesan los temas de concurrencia en java debes estudiar acerca del API de concurrencia "java.util.concurrent" (
docs). Muchos de los problemas de concurrencia q te vas a encontrar ya tienen soluciones (e incluso patrones) implementadas.
Aquí te dejo un pequeño tutorial:
http://www.vogella.com/tutorials/Jav...y/article.html
en el cap 8 resuelven un problema muy parecido al tuyo, basándose en ese código podemos llegar a este:
Código Java:
Ver originalimport java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableFutures {
// Cantidad de hilos
private static final int NTHREDS = 3;
public static void main
(String[] args
) {
ExecutorService executor = Executors.newFixedThreadPool(NTHREDS);
List<Future<Long>> list = new ArrayList<Future<Long>>();
Callable<Long> worker = new MyCallable();
for (int i = 0; i < NTHREDS; i++) {
Future<Long> submit = executor.submit(worker);
list.add(submit);
}
for (Future<Long> future : list) {
try {
System.
out.
println("Total is: " + future.
get()); e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
executor.shutdown();
}
}
class MyCallable implements Callable<Long> {
@Override
long sum = 0;
for (long i = 0; i < 100; i++) {
sum += i;
}
return sum;
}
}
slds;
nup_