使用單獨的線程在java中讀取和寫入文件

Question

我創建了兩個線程並修改了run函數，以便一個線程讀取一行，另一個線程將同一行寫入新文件。 這種情況發生，直到整個文件被復制。 我得到的問題是，即使我已經使用變量來控制線程逐個執行，但線程執行不均勻，即一個線程執行多次，然后控件傳輸。 我附上代碼的任何解決方案。 我是java新手，因為它只用於類分配，所以代碼可能不是最優化的。

  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

Answer 1

您無法控制線程執行的順序。 但是，要通過單獨的線程執行讀寫操作，您應該使用具有以下屬性的BlockingQueue：

一個隊列，它還支持在檢索元素時等待隊列變為非空的操作，並在存儲元素時等待隊列中的空間可用。

ReaderThread將從輸入文件中讀取。

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將寫入輸出文件。

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();
    } 

  }

}

從Launcher類開始你的多線程讀寫。

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();

  }

 }

Answer 2

這是我的解決方案。 我的想法是使用我們的線程將讀取和寫入的實際文件名。 我們需要確保只有一個問題，即沒有兩個線程試圖在同一個文件上運行。 解決方案是在run方法中簡單地使用同步代碼塊。

我們必須記住，字符串在Java中是不可變的。 考慮以下：

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

現在，我們必須問自己如何jvm重用不可變的“test.txt”。 在這種情況下，s1和s2 String對象都指向相同的“test.txt”。

理解這個概念對我們來說也是有用的：

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 );
    } 

}
}