He creado dos hilos y modificado la función de ejecución de modo que un hilo lee una línea y el otro escribe la misma línea para el nuevo archivo. Esto sucede hasta que todo archivo es copiado. El problema que tengo es que a pesar de que he utilizado variables a controlar que los hilos ejecutar uno por uno, pero todavía los hilos se ejecutan de manera desigual yo.e un subproceso se ejecuta varias veces y, a continuación, el control de las transferencias. Ninguna de las soluciones me han adjunto el código. Soy nuevo en java, ya que es sólo para la asignación de clase de modo que el código podría no ser el más optimizado.

  public class thread1 extends Thread {
//To create producer and consumer as threads
//Shared variable
public static int x = 0;//checks if all lines are read                                      
public static String line; /holds lines from file
public static int j = 0;//variable to switch between threads based upon its value
public thread1(String threadName) {     //Constuctor
super(threadName);      //Call to constructor of Thread class
}
public void run() {
while (x != -1)
{
if (Thread.currentThread().getName().contains("Reader")) {
if (x != -1&&j==0)
{
j=1;
String fileName = "d:/salfar.txt";
try {
//FileReader reads text files in the default encoding.
FileReader fileReader =
new FileReader(fileName);
//Always wrap FileReader in BufferedReader.
BufferedReader bufferedReader =
new BufferedReader(fileReader);
for (int check = 0; check <= x; check++) {
line = bufferedReader.readLine();
}
if (line == null) {
x = -1;
} else {
System.out.println(line);
x++;
}
//Always close files.
bufferedReader.close();
} catch (FileNotFoundException ex) {
System.out.println(
"Unable to open file '"
+ fileName + "'");
} catch (IOException ex) {
System.out.println(
"Error reading file '"
+ fileName + "'");
//Or we could just do this: 
//ex.printStackTrace();
}
}
yield();
} 
else if (Thread.currentThread().getName().contains("writer")) {
if (x != -1 && line != null&&j==1)
{
j=0;
String fileName = "d:/salfar1.txt";
try {
//Assume default encoding.
FileWriter fileWriter =
new FileWriter(fileName, true);
//Always wrap FileWriter in BufferedWriter.
BufferedWriter bufferedWriter =
new BufferedWriter(fileWriter);
//Note that write() does not automatically
//append a newline character.
bufferedWriter.write(line);
bufferedWriter.newLine();
System.out.println("y");
//Always close files.
bufferedWriter.close();
} catch (IOException ex) {
System.out.println(
"Error writing to file '"
+ fileName + "'");
//Or we could just do this:
//ex.printStackTrace();
}
}     
Thread.yield();
}
else{}
}
}
public static void main(String[] args) {
thread1 p = new thread1("Reader");
thread1 c = new thread1("writer");
p.start();
c.start();
}
}
Thanks
  • porque lamentablemente eso es lo que Hilos hacer !!!
  • Nos muestran su código correspondiente. También es una mala idea para leer una línea de un hilo y, a continuación, escribir en otro, ya que lo hace esencialmente secuencial. En cambio, si usted fuera a leer en un buffer, usted podría tener los hilos trabajo más paralelizado manera.
  • publica tu código [ hasta ahora lo que has hecho]
  • y que están atrapados en producer and consumer problem uso esperar y notificar a la lógica de deshacerse de él y post algo de código para obtener ayuda
  • adjunto el código . Soy nuevo en java, ya que es sólo para la asignación de clase de modo que el código podría no ser el más optimizado.
  • es una asignación que es la razón por la que no tengo ninguna opción pero para aplicar esta forma, en manera secuencial.
  • Hacer una clase separada para el lector y para el escritor, de lo contrario se le acaba de confundir a sí mismo.
  • como he mencionado que es una cesión por lo que puede ser hecho por uno sólo en la clase ???
  • Se puede hacer con una sola clase de seguro, pero usted tendrá una mayor oportunidad de echar a perder las cosas. Usted puede usar un par de interna estática de las clases en su lugar, y también todo el código en un único archivo. Su Thread.yield() llamadas también son inútiles, y sospecho que hay problemas mucho más con su código, a fin de ponerlos en clases separadas ayudará a usted y a las personas que te están ayudando.
  • eso es algo agradable info @Kayaman voy a discutir con el maestro. gracias por la ayuda

2 Comentarios

  1. 11

    Usted no puede controlar el orden de ejecución de subprocesos. Sin embargo, para realizar la operación de lectura y escritura a través de hilos separados, debe utilizar BlockingQueue que tiene las siguientes propiedades:

    Una Cola que además soporta las operaciones que espere a que la cola no vacía cuando la recuperación de un elemento, y espere a que el espacio disponible en la cola, cuando el almacenamiento de un elemento.

    ReaderThread se lee desde el archivo de entrada.

    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.util.concurrent.BlockingQueue;
    public class ReaderThread implements Runnable{
    protected BlockingQueue<String> blockingQueue = null;
    public ReaderThread(BlockingQueue<String> blockingQueue){
    this.blockingQueue = blockingQueue;     
    }
    @Override
    public void run() {
    BufferedReader br = null;
    try {
    br = new BufferedReader(new FileReader(new File("./inputFile.txt")));
    String buffer =null;
    while((buffer=br.readLine())!=null){
    blockingQueue.put(buffer);
    }
    blockingQueue.put("EOF");  //When end of file has been reached
    } catch (FileNotFoundException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    } catch(InterruptedException e){
    }finally{
    try {
    br.close();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }
    }

    WriterThread va a escribir a un archivo de salida.

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.PrintWriter;
    import java.util.concurrent.BlockingQueue;
    public class WriterThread implements Runnable{
    protected BlockingQueue<String> blockingQueue = null;
    public WriterThread(BlockingQueue<String> blockingQueue){
    this.blockingQueue = blockingQueue;     
    }
    @Override
    public void run() {
    PrintWriter writer = null;
    try {
    writer = new PrintWriter(new File("outputFile.txt"));
    while(true){
    String buffer = blockingQueue.take();
    //Check whether end of file has been reached
    if(buffer.equals("EOF")){ 
    break;
    }
    writer.println(buffer);
    }               
    } catch (FileNotFoundException e) {
    e.printStackTrace();
    } catch(InterruptedException e){
    }finally{
    writer.close();
    } 
    }
    }

    De Lanzador de inicio de la clase su multiproceso leer y escribir.

    import java.util.concurrent.ArrayBlockingQueue;
    import java.util.concurrent.BlockingQueue;
    public class Launcher {
    public static void main(String[] args) {
    BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1024);
    ReaderThread reader = new ReaderThread(queue);
    WriterThread writer = new WriterThread(queue);
    new Thread(reader).start();
    new Thread(writer).start();
    }
    }
    • se intenta hacerlo lo antes posible.
  2. -1

    Aquí está mi solución. Mi idea es usar el nombre de archivo que nuestros hilos a leer y escribir. Sólo hay un problema que debemos asegurarnos de que no hay dos hilos están tratando de operar en el mismo archivo. La solución a esto es simplemente tener un sincronizado bloque de código en el método run.

    Debemos recordar que las Cadenas no son mutables en Java. Considere lo siguiente:

    String s1 = "test.txt";
    String s2 = "test.txt";

    Ahora, debemos preguntarnos a nosotros mismos ¿cómo la jvm reutilizar el inmutable «test.txt». En este caso, ambos s1 & s2 objetos String punto a la misma «test.txt».

    La comprensión de este concepto también va a hacer el truco para nosotros:

    public class Client {
    public static void main( String args [] ) {
    String filename = "test.txt";
    String filename2 = "test.txt";
    Reader reader = new Reader( filename ) ; 
    Writer writer = new Writer( filename2 ) ;
    while(true) {
    reader.run();
    writer.run();
    }
    }
    } 
    public class Writer implements Runnable {
    public String filename; 
    public Writer( String filename ) {
    this.filename = filename; 
    }
    @Override
    public void run() { 
    synchronized( this.filename ) {
    System.out.println( "writing to a file:" + this.filename );  
    }  
    }
    }
    public class Reader implements Runnable {
    public String filename; 
    public Reader( String filename ) {
    this.filename = filename; 
    }
    @Override
    public void run() { 
    synchronized( this.filename ) {
    System.out.println( "reading a file:" + this.filename );
    } 
    }
    }

Dejar respuesta

Please enter your comment!
Please enter your name here