带线程池的Java线程队列

我制作了一个程序，它使用一个线程将文件中的数据读取到一个链表中，我们称之为LL1。由此，我创建了一个线程池，为每个线程分配一个处理任务，该任务从LL1读取数据，并将其计算结果输出到一个新的链表。 从这里，我需要将每个线程的新链表输出到一个文件中。我试图以顺序块的形式输出每个链表，这样线程就不会混合数据，所以我使用了一个同步点，如下所示：

public synchronized void appendContents(List<Vector2> output1) {
    try {
        sFileName = outFilePath + "\\file" +fileCount+ ".cntr";
        File oFile = new File(sFileName);
        if (!oFile.exists()) {
            oFile.createNewFile();
        }
        if (oFile.canWrite()) {
            //BufferedWriter oWriter = new BufferedWriter(new FileWriter(sFileName, true));
             FileWriter wstream = new FileWriter(oFile, true);
             BufferedWriter outWriter = new BufferedWriter(wstream);
             for(int i = 0; i < output1.size(); i++)
             {
                //replace the space marker values with a newline
                if(output1.get(i).y == -200.0){
                outWriter.newLine();
                }else{
                outWriter.write(String.valueOf(output1.get(i).x) + " " + String.valueOf(output1.get(i).y) + " " + String.valueOf(interval));
                outWriter.newLine();    
                }
             }           
             outWriter.close();
        }
    }
    catch (IOException oException) {
        throw new IllegalArgumentException("Error appending/File cannot be written: \n" + sFileName);
    }

如果有人能给我一个正确的方向，我将不胜感激。 谢谢

---

杰克

同步的目的是在共享资源上同步，以便一次只有一个

线程

可以访问关键部分。我假设您正在生成三个

Thread

实例，每个实例都在自己的对象上调用

appendContents

---

synchronized

方法在

此

上隐式同步，但由于所有三个

线程

都在不同的对象上同步，即不同的

此

，没有任何东西阻止它们。

同步的

的目的是在共享资源上同步，以便只有一个
线程在同一时间访问关键部分。我假设您正在生成三个
Thread
实例，每个实例都在自己的对象上调用
appendContents

synchronized
方法隐式地在
this
上同步，但由于所有三个
线程都在不同的对象上同步，即，不同的
this
，因此没有任何东西阻止它们。
据我所知，您每次都为每个列表元素运行新任务吗

然后您可以编写可调用任务->将结果保存到功能中。将功能放入列表vs结果（resultFeatureFromList）。最后做一些像这样的事情：
我使用番石榴库中的函数

Iterables.transform(resultList<Feature>,new Function(){
   public resultComputition apply(Feature resultFeatureFromList){
               return resultFeatureFromList.get();
   }
});

Iterables.transform（结果列表，新函数（）{
公共结果计算应用（要素结果要素列表）{
返回resultFeatureFromList.get（）；
}
});

总之，您将以正确的顺序运行所有任务。在拉取所有数据之后，只需等待结果。
据我所知，您每次都为每个列表元素运行新任务吗

然后您可以编写可调用任务->将结果保存到功能中。将功能放入列表vs结果（resultFeatureFromList）。最后做一些像这样的事情：
我使用番石榴库中的函数

Iterables.transform(resultList<Feature>,new Function(){
   public resultComputition apply(Feature resultFeatureFromList){
               return resultFeatureFromList.get();
   }
});

Iterables.transform（结果列表，新函数（）{
公共结果计算应用（要素结果要素列表）{
返回resultFeatureFromList.get（）；
}
});

总之，您将以正确的顺序运行所有任务。在提取完所有内容后，只需等待结果。
从中详细说明，您可以按如下方式构建应用程序：

public synchronized void appendContents(List<Vector2> output1) {
    try {
        sFileName = outFilePath + "\\file" +fileCount+ ".cntr";
        File oFile = new File(sFileName);
        if (!oFile.exists()) {
            oFile.createNewFile();
        }
        if (oFile.canWrite()) {
            //BufferedWriter oWriter = new BufferedWriter(new FileWriter(sFileName, true));
             FileWriter wstream = new FileWriter(oFile, true);
             BufferedWriter outWriter = new BufferedWriter(wstream);
             for(int i = 0; i < output1.size(); i++)
             {
                //replace the space marker values with a newline
                if(output1.get(i).y == -200.0){
                outWriter.newLine();
                }else{
                outWriter.write(String.valueOf(output1.get(i).x) + " " + String.valueOf(output1.get(i).y) + " " + String.valueOf(interval));
                outWriter.newLine();    
                }
             }           
             outWriter.close();
        }
    }
    catch (IOException oException) {
        throw new IllegalArgumentException("Error appending/File cannot be written: \n" + sFileName);
    }


让线程读取文件内容
对于文件中的每个项目，向线程池提交一个
Callable
任务
将返回的
Future
存储在一个列表或列表中-您可以定义所需的粒度
在同一线程中打开输出文件，并遍历结果列表进行写入


例如：

void readAndOutput(String inputFilePath, String outputFilePath) {
    List<List<Future<Result>>> results = readAndSpawnTask(inputFilePath);

    PrintWriter out = new PrintWriter(new File(outputFilePath));

    for (List<Future<Result>> block : results) {
        for (Future<Result> r : block) {
            out.println(r.get().toString());
        }
    }

    out.flush();
    out.close();
}


List<List<Future<Result>>> readAndSpawnTask(String path) {
    List<List<Future<Result>>> results = new ArrayList<>(numOfBlocks);
    BufferedReader in = new BufferedReader(new FileReader(new File(path)));

    for (int i = 0; i < numOfBlocks; ++i) {
        results.add(new LinkedList<Future<Result>>());
    }

    for (String line = in.readLine(); line != null; line = in.readLine()) {
        int respectiveBlock;
        Callable<Result> task;
        // Process line and convert it into a task of your own.
        // Determine in which block the result goes into.
        Future<Result> r = threadPool.submit(task);
        results.get(respectiveBlock).add(r);
    }

    in.close();

    return results;
}

void readAndOutput（字符串inputFilePath，字符串outputFilePath）{
列表结果=readAndSpawnTask（inputFilePath）；
PrintWriter out=新的PrintWriter（新文件（outputFilePath））；
用于（列表块：结果）{
用于（未来r:区块）{
out.println（r.get（）.toString（））；
}
}
out.flush（）；
out.close（）；
}
列表readAndSpawnTask（字符串路径）{
列表结果=新的ArrayList（numOfBlocks）；
BufferedReader in=新的BufferedReader（新文件读取器（新文件（路径））；
对于（int i=0；i

如果您想要和/或需要并发性，可以在单个线程中访问文件。使用
Future
列表，您可以保证以正确的顺序写入结果，并且您的主线程将阻塞，直到所需的结果准备就绪

当然，您仍然需要考虑上述代码中可能引发的异常。
详细说明，您可以按照以下方式构建应用程序：

public synchronized void appendContents(List<Vector2> output1) {
    try {
        sFileName = outFilePath + "\\file" +fileCount+ ".cntr";
        File oFile = new File(sFileName);
        if (!oFile.exists()) {
            oFile.createNewFile();
        }
        if (oFile.canWrite()) {
            //BufferedWriter oWriter = new BufferedWriter(new FileWriter(sFileName, true));
             FileWriter wstream = new FileWriter(oFile, true);
             BufferedWriter outWriter = new BufferedWriter(wstream);
             for(int i = 0; i < output1.size(); i++)
             {
                //replace the space marker values with a newline
                if(output1.get(i).y == -200.0){
                outWriter.newLine();
                }else{
                outWriter.write(String.valueOf(output1.get(i).x) + " " + String.valueOf(output1.get(i).y) + " " + String.valueOf(interval));
                outWriter.newLine();    
                }
             }           
             outWriter.close();
        }
    }
    catch (IOException oException) {
        throw new IllegalArgumentException("Error appending/File cannot be written: \n" + sFileName);
    }


让线程读取文件内容
对于文件中的每个项目，向线程池提交一个
Callable
任务
将返回的
Future
存储在一个列表或列表中-您可以定义所需的粒度
在同一线程中打开输出文件，并遍历结果列表进行写入


例如：

void readAndOutput(String inputFilePath, String outputFilePath) {
    List<List<Future<Result>>> results = readAndSpawnTask(inputFilePath);

    PrintWriter out = new PrintWriter(new File(outputFilePath));

    for (List<Future<Result>> block : results) {
        for (Future<Result> r : block) {
            out.println(r.get().toString());
        }
    }

    out.flush();
    out.close();
}


List<List<Future<Result>>> readAndSpawnTask(String path) {
    List<List<Future<Result>>> results = new ArrayList<>(numOfBlocks);
    BufferedReader in = new BufferedReader(new FileReader(new File(path)));

    for (int i = 0; i < numOfBlocks; ++i) {
        results.add(new LinkedList<Future<Result>>());
    }

    for (String line = in.readLine(); line != null; line = in.readLine()) {
        int respectiveBlock;
        Callable<Result> task;
        // Process line and convert it into a task of your own.
        // Determine in which block the result goes into.
        Future<Result> r = threadPool.submit(task);
        results.get(respectiveBlock).add(r);
    }

    in.close();

    return results;
}

void readAndOutput（字符串inputFilePath，字符串outputFilePath）{
列表结果=readAndSpawnTask（inputFilePath）；
PrintWriter out=新的PrintWriter（新文件（outputFilePath））；
用于（列表块：结果）{
用于（未来r:区块）{
out.println（r.get（）.toString（））；
}
}
out.flush（）；
out.close（）；
}
列表readAndSpawnTask（字符串路径）{
列表结果=新的ArrayList（numOfBlocks）；
BufferedReader in=新的BufferedReader（新文件读取器（新文件（路径））；
对于（int i=0；i