Question

我正在尝试使用线程读取三个文件，然后将内容传递给writer类以将其写入另一个文件。与第一个文件关联的线程（其中包含换行符）在每次换行后返回。任何人都可以告诉我为什么会这样。我将粘贴读者类的代码。

package filehandling;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class FileReading extends Thread{
    BufferedReader fis;
    int count=0;
    FileWriting fw;
    String str1, str2;
     String ssr;
    public FileReading(String str) throws IOException
    {

        //getting filename
        File f= new File(str);
        String strin;
        strin= f.getName();
        System.out.println(".." + strin);

        //splitting filename to get the initial name
        String stra[]= new String[2];

         stra= strin.split("\\.");
         str1= stra[0];
         str2= stra[1];

        System.out.println("extension name :" + str2);
        System.out.println("filename :" + str1);


        //associating file to input stream
        fis= new BufferedReader(new FileReader(f));

    }

     public void run()
       {


           try
           {
    while((ssr=fis.readLine())!=null)
               {
                   //file contents
                   System.out.println(ssr);

                   //writer thread
                   fw= new FileWriting(str1,ssr);
                   fw.start();

                   //assigning thread time to read,else next thread comes in
                   join(1000);
               }
           }

           catch(Exception e)
           {
               System.out.println("exception : " + e.getMessage() + e.getStackTrace());
           }

       }
}

Answer 1

在读取单个文件的过程中启动多个线程没有任何意义。从文件数据流中读取没有并行执行的机会。但是你可以通过在每个线程中使用普通循环使用三个线程来并行读取三个独立的文件。

还有另一种误解;你似乎认为你必须为线程分配时间。这是错的，你不需要考虑那个，你不能按照你尝试的方式去做。当您启动三个线程时，每个线程都会读取和写入一个文件，当没有可用数据时，所有线程都会进入休眠状态并继续处理新数据。操作系统会适当地为它们分配CPU时间。

由于您没有给出写入部分，我无法为您的任务提供代码示例，但这是一个简单的示例，即并行读取三个文件并将其内容作为String返回：

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ReadFile implements Callable<String>
{
  public static void main(String[] args) throws InterruptedException
  {
    // enter the three file names here
    String[] file={
      "",
      "",
      ""};
    ExecutorService executorService = Executors.newFixedThreadPool(file.length);
    List<Callable<String>> jobs=new ArrayList<>(file.length);
    for(String f:file) jobs.add(new ReadFile(f));
    List<Future<String>> all = executorService.invokeAll(jobs);
    System.out.println("all files have been read in");
    int i=0; for(Future<String> f:all) { i++;
      System.out.println("file "+i+": ");
      try
      {
        String contents = f.get();
        System.out.println(contents);
      } catch(ExecutionException ex)
      {
        ex.getCause().printStackTrace();
      }
    }
  }

  final String fileName;

  public ReadFile(String file) {
    fileName=file;
  }
  public String call() throws Exception {
    String newLine=System.getProperty("line.separator");
    StringBuilder sb=new StringBuilder();
    try(BufferedReader r=new BufferedReader(new FileReader(fileName))) {
      for(;;) {
        String line=r.readLine();
        if(line==null) break;
        sb.append(line).append(newLine);
      }
    }
    return sb.toString();
  }
}

行executorService.invokeAll将调用所有提供的call个实例的ReadFile个方法，每个方法都在另一个Thread中。这些线程在循环中读取它们的文件，每当I / O系统没有新的数据时就会被阻塞，让其他线程有机会继续。但是，不要指望一个线程一个接一个地处理文件，三个线程的运行速度要快得多。限制因素是硬盘/ SSD /等的I / O速度。当所有文件都位于不同的设备上时，您最有可能通过多个线程获得更高的速度。

如果线程不仅仅是读取或写入，而且还执行某些计算，那么事情会有所不同。

文件处理和线程

1 个答案: