[SOLUCIONADO] Duda Ejecución Hilos

[rgf1987]

Buenas, me estoy preparando la certificación SCJP de java y viendo un ejemplo de hilos me ha surgido una duda.

Teniendo el siguiente código:

Código Java:

class Reader extends Thread {
    Calculator c;
 
    public Reader(Calculator calc) {
        c = calc;
    }
 
    public void run() {
        synchronized (c) {
            try {
                System.out.println("Waiting for calculation...");
                c.wait();
            } catch (InterruptedException e) {
            }
            System.out.println("Total is: " + c.total);
        }
    }
 
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        new Reader(calculator).start();
        new Reader(calculator).start();
        new Reader(calculator).start();
        calculator.start();
    }
}
 
class Calculator extends Thread {
    int total;
 
    public void run() {
        synchronized (this) {
            for (int i = 0; i < 100; i++) {
                total += i;
            }
            notifyAll(); 
        }
    }
}
 

Pensaba en un principio que la salida era:
Waiting for calculation...
Waiting for calculation...
Waiting for calculation...
Total is: 4950
Total is: 4950
Total is: 4950

Porque se crean los 3 hilos de la clase Reader y se ponen en espera, y luego se crea el hilo de la clase Calculator y se hace el notifyall() que los libera...
Pero para mi sorpresa, no siempre se da ese resultado, ya que por lo visto los hilos se ejecutan en un orden aleatorio en función de lo que decida la JVM.

Existe alguna forma, de controlar el orden en la que se ejecutan los hilos en la JVM? Si por ejemplo quiero que se ejecute el hilo

calculator.start();

en último lugar siempre, que debería añadir al código?
He estado haciendo pruebas, pense en ponerle un booleano y comprobar desde el run() de calculator que todos los hilos Reader estuviesen ejecutandose, pero esto no me sirve si la JVM ejecuta en un orden aleatorio.

El método yield(), se utiliza para asignar prioridades pero en este caso como debería utilirse??

[rgf1987]

me auto respondo, lo hice de esta forma y funciona correctamente... aunque me parece demasiado lío, debería haber una forma más fácil de hacerlo:

Código Java:

import java.util.ArrayList;
import java.util.List;
 
class Reader extends Thread {
    Calculator c;
    boolean ejecutado=false;
 
    public Reader(Calculator calc) {
        c = calc;
    }
 
    public void run() {
        synchronized (c) {
            try {
                System.out.println("Waiting for calculation...");
                ejecutado=true;
                c.wait();
            } catch (InterruptedException e) {
            }
            System.out.println("Total is: " + c.total);
        }
    }
 
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        List<Reader> list = new ArrayList<Reader>();
        Reader reader1 = new Reader(calculator);
        Reader reader2 = new Reader(calculator);
        Reader reader3 = new Reader(calculator);
        reader1.start();
        reader2.start();
        reader3.start();
        list.add(reader1);
        list.add(reader2);
        list.add(reader3);
        calculator.listReader = list;
        calculator.start();
    }
}
 
class Calculator extends Thread {
    int total;
    List<Reader> listReader;
    boolean todosEjecutados = false;
    public void run() {
        while(!todosEjecutados){
            for(Reader r:listReader){
                if(r.ejecutado){
                    todosEjecutados=true;
                }
                else{
                    todosEjecutados=false;
                    break;
                }
            }
            if(todosEjecutados!=false){
                synchronized (this) {
                    for (int i = 0; i < 100; i++) {
                        total += i;
                    }
                    notifyAll(); 
                }
            }
        }   
    }
}
 

He creado una lista con los hilos Reader, y mediante un booleano indico si el hilo ha sido ejecutado o no:

Código Java:

synchronized (c) {
            try {
                System.out.println("Waiting for calculation...");
                ejecutado=true;
                c.wait();
            } catch (InterruptedException e) {
            }
            System.out.println("Total is: " + c.total);
        }
 

Luego cuando se llama al hilo de Calculator, recorro la lista de objetos Reader y se ejecuta un bucle infinito hasta que todos los hilos de la lista se han ejecutado.

Código Java:

while(!todosEjecutados){
            for(Reader r:listReader){
                if(r.ejecutado){
                    todosEjecutados=true;
                }
                else{
                    todosEjecutados=false;
                    break;
                }
            }
            if(todosEjecutados!=false){
                synchronized (this) {
                    for (int i = 0; i < 100; i++) {
                        total += i;
                    }
                    notifyAll(); 
                }
            }
        }
 

Me estoy liando demasiado???

[nup_]

Hola:
El problema con el primer código está en que dentro del run() de Reader

Código Java:

c.wait();
 

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:

import 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());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        executor.shutdown();
    }
} 
 
class MyCallable implements Callable<Long> {
    @Override
    public Long call() throws Exception {
        long sum = 0;
        for (long i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
 
}
 

slds;

nup_

[rgf1987]

Buenas

gracias por la aclaración nup_, el tema de Futures, Callables y Executors, no entra en la certificación que estoy preparando, así que demomento me lo apunto, pero lo dejo para más adelante jeje.