Estoy tratando de leer dos archivos de texto (que tienen el mismo número de líneas, es decir, 10000) usando dos subprocesos separados, un archivo que contiene cadenas y el otro que contiene enteros. Luego, quiero escribir en otro archivo de texto (Cadena, Entero) los valores de las posiciones correspondientes en los conjuntos de resultados, cada uno en una línea distinta. Para estos fines, estoy usando dos clases que implementan la interfaz Runnable.
El problema al que me enfrento es que cada vez que ejecuto el programa, existe la posibilidad de que uno de los subprocesos esté bloqueando la ejecución, y no entiendo por qué teniendo en cuenta que estoy usando esperar() y notificar() en un bloque synchronized . Más específicamente, a veces el programa se ejecuta con éxito y finaliza la ejecución, mientras que en la mayoría de los casos se detiene en varias etapas (por ejemplo, ~3000 de 10000 líneas escritas, o incluso ~500).
citireInteger es una referencia al otro hilo que está leyendo el archivo Integer.
Aquí hay un código relevante de las clases que se ocupan de la lectura de los archivos String y Integer, respectivamente:
@Override public void run(){ ........ try { pw = new PrintWriter(new BufferedWriter(new FileWriter("rezultat.txt", true))); for(int i = 0; i < strings.size(); i++){ synchronized(this){ pw.write(strings.get(i)); } synchronized(citireInteger){ citireInteger.notifyAll(); } try{ synchronized(this){ wait(); } } catch(InterruptedException e){ e.printStackTrace(); } } } catch(FileNotFoundException e){ e.printStackTrace(); } catch(IOException e){ e.printStackTrace(); } finally{ pw.close(); } synchronized(citireInteger){ citireInteger.notify(); } }El hilo que lee el archivo Integer:
public void run(){ ........... try{ pw = new PrintWriter(new BufferedWriter(new FileWriter("rezultat.txt", true))); for(int i = 0; i < ints.size(); i++){ synchronized(this){ pw.write(ints.get(i) + '\n'); System.out.println(ints.get(i)); } synchronized(citireString){ citireString.notifyAll(); } try{ synchronized(this){ wait(); } } catch(InterruptedException e){ e.printStackTrace(); } } } catch(FileNotFoundException e){ e.printStackTrace(); } catch(IOException e){ e.printStackTrace(); } finally{ pw.close(); } synchronized(citireString){ citireString.notify(); } }Lo que sucede es que un subproceso llama a notifyAll a todos en el otro subproceso, luego se desconecta antes de sincronizar en su propio escritor para llamar a wait . El otro subproceso escribe, sincroniza en su escritor y llama a wait . Luego, el primer subproceso se vuelve a conectar, se sincroniza en su escritor y llama a wait . Ahí está tu punto muerto.
Mejor sería tener ambos subprocesos sincronizados en el mismo objeto para escribir. Lo mejor sería almacenar los datos en la memoria de una manera segura para subprocesos y escribir desde un solo subproceso una vez que se completó la lectura de ambos subprocesos.
Cuando notifique al otro subproceso, el otro subproceso solo lo verá cuando los otros subprocesos lo estén esperando. Si el otro subproceso está fuera de ese bloque sincronizado, y entra en ese bloque sincronizado después de que se le notifique, luego esperará una notificación que no sucederá, o más bien, que sucedió antes de comenzar a esperar. Es difícil determinar realmente cuál es el objetivo de este ejercicio, pero supongo que se trata de dos subprocesos que se turnan para escribir. Bien, entonces, ¿qué tal hacer que el bloque sincronizado (citireInt/String) abarque todo su código! De esta manera, el otro subproceso que intenta obtener un bloqueo SOLO obtendrá ese bloqueo CUANDO el otro subproceso esté esperando. Eso creo que garantizaría que no haya bloqueo y el resultado sería que ambos subprocesos se turnaran, uno por uno.
Editar: no del todo exactamente como lo describí, pero los puntos clave son dónde sincronizar ...
public void run() { ........... try { pw = new PrintWriter(new BufferedWriter(new FileWriter("rezultat.txt", true))); synchronized(this) { for(int i = 0; i < ints.size(); i++) { pw.write(ints.get(i) + '\n'); System.out.println(ints.get(i)); synchronized (citireString) { citireString.notifyAll(); } try { wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } catch (Throwable e) { e.printStackTrace(); } finally { pw.close(); } }