1

在将内容从对象写入文件时,我有多个线程调用一种方法,如下所示: 当我使用 1 个线程测试此方法时,预期会输出到我的文件中。但是,对于多个线程,文件的输出是混乱的。如何使这个线程安全?

void (Document doc, BufferedWriter writer){
       Map<Sentence, Set<Matrix>> matrix = doc.getMatrix();
       for(Sentence sentence : matrix.keySet()){
           Set<Matrix> set = doc.getMatrix(sentence);
           for(Matrix matrix : set){
               List<Result> results = ResultGenerator.getResult();
               writer.write(matrix, matrix.frequency());
               writer.write(results.toString());
               writer.write("\n");
           }
       }
}

编辑:

我添加了这一行 List<Result> results = ResultGenerator.getResult()。我真正想要的是使用多个线程来处理这个方法调用,因为这部分很昂贵并且需要很多时间。写作部分很快,我真的不需要多线程。

鉴于此更改,有没有办法使此方法调用在并发环境中安全?

4

6 回答 6

2

本质上,您最终会受到单个文件的限制。没有全局变量,也没有发布任何内容,因此该方法是线程安全的。

但是,如果处理确实需要很多时间,您可以使用并行流并将结果发布到并发哈希图或阻塞队列。但是,您仍然有一个消费者可以写入文件。

于 2017-10-10T15:56:17.030 回答
1

我不太精通 Java,所以我将提供一个与语言无关的答案。

您要做的是将矩阵转换为结果,然后将它们格式化为字符串,最后将它们全部写入流中。

目前,您在处理每个结果后立即写入流,因此当您将多线程添加到您的逻辑时,您最终会在流中遇到竞争条件。

您已经发现只有调用 forResultGenerator.getResult()应该并行完成,而流仍然需要按顺序访问。

现在你只需要把它付诸实践。按顺序执行:

  • 建立一个列表,其中每个项目都是生成结果所需的
  • 并行处理此列表,从而生成所有结果(这是一个map操作)。您的项目列表将成为结果列表。
  • 现在您已经有了结果,因此您可以按顺序迭代它们以格式化并将它们写入流中。

我怀疑 Java 8 提供了一些工具来以功能方式制作所有内容,但正如我所说的,我不是 Java 人,所以我无法提供代码示例。我希望这个解释就足够了。

@编辑

F# 中的这个示例代码解释了我的意思。

open System

// This is a pretty long and nasty operation!
let getResult doc =
    Threading.Thread.Sleep(1000)
    doc * 10

// This is writing into stdout, but it could be a stream...
let formatAndPrint =
    printfn "Got result: %O"

[<EntryPoint>]
let main argv =
    printfn "Starting..."

    [| 1 .. 10 |] // A list with some docs to be processed
    |> Array.Parallel.map getResult // Now that's doing the trick
    |> Array.iter formatAndPrint

    0
于 2017-10-10T03:03:39.757 回答
1

如果您需要按预定顺序排列的最终文件,请不要使用多线程,否则您将无法获得预期的结果。

如果您认为使用多线程您的程序会在 I/O 输出方面执行得更快,那么您可能错了;由于同步导致的锁定或开销,您实际上将获得比单个线程更低的性能。

如果您尝试编写一个非常大的文件,则Document实例的顺序无关紧要,并且您认为您的 writer 方法会遇到 CPU 瓶颈(但我可以从我们的代码中找出的唯一可能原因是frequency()方法调用),什么您可以做的是让每个线程拥有自己的写入临时文件的 BufferedWriter,然后添加一个等待所有线程的附加线程,然后使用连接生成最终文件。

于 2017-10-09T20:07:52.233 回答
0

如果您的代码使用不同的 doc 和 writer 对象,那么您的方法已经是线程安全的,因为它不访问和使用实例变量。

如果您正在编写将相同的 writer 对象传递给该方法,则可以使用以下方法之一,具体取决于您的需要:

void (Document doc, BufferedWriter writer){
       Map<Sentence, Set<Matrix>> matrix = doc.getMatrix();
       for(Sentence sentence : matrix.keySet()){
           Set<Matrix> set = doc.getMatrix(sentence);
           for(Matrix matrix : set){
               List<Result> results = ResultGenerator.getResult();

               // ensure that no other thread interferes while the following
               // three .write() statements are executed.
               synchronized(writer) {
                   writer.write(matrix, matrix.frequency()); // from your example, but I doubt it compiles
                   writer.write(results.toString());
                   writer.write("\n");
               }
           }
       }
}

或使用临时 StringBuilder 对象无锁:

void (Document doc, BufferedWriter writer){
       Map<Sentence, Set<Matrix>> matrix = doc.getMatrix();
       StringBuilder sb = new StringBuilder();
       for(Sentence sentence : matrix.keySet()){
           Set<Matrix> set = doc.getMatrix(sentence);
           for(Matrix matrix : set){
               List<Result> results = ResultGenerator.getResult();
               sb.append(matrix).append(matrix.frequency());
               sb.append(results.toString());
               sb.append("n");
           }
       }
       // write everything at once
       writer.write(sb.toString();
}
于 2017-10-10T19:08:25.417 回答
-2

您可以锁定一个方法,然后在完成后将其解锁。通过将同步放在方法之前,您可以确保一次只有一个线程可以执行它。同步会降低 Java 的速度,因此只应在必要时使用。

ReentrantLock lock = new ReentrantLock();

 /* synchronized */ 
public void run(){

    lock.lock();

    System.out.print("Hello!");

    lock.unlock();

 }

这就像同步一样锁定方法。您可以使用它来代替同步,这就是上面注释掉同步的原因。

于 2017-10-09T19:31:06.860 回答
-2

我会让它同步。在这种情况下,您的应用程序中只允许一个线程同时调用此方法 => 没有混乱的输出。如果您有多个应用程序正在运行,您应该考虑文件锁定之类的东西。

同步方法的示例:

public synchronized void myMethod() {
    // ...
}

此方法对每个线程都是专有的。

于 2017-10-09T19:12:50.920 回答