Java—并行处理文档

我有5个文件（比如说），我对每个文件都有一些处理。这里的处理包括打开文档/文件、读取数据、执行一些文档操作（编辑文本等）。对于文档操作，我可能会使用docx4j或apachepoi。但我的用例是这样的——我想以某种方式利用CPU上的多个可用内核并行处理这些4-5个文档。对每个文档的处理是相互独立的

---

在Java中实现这种并行处理的最佳方法是什么。我以前在java中使用过

ExecutorService

，也使用过

Thread

类。但是我对诸如

Streams

或

RxJava

之类的新概念知之甚少。这个任务可以通过使用Java中的并行流来实现吗？使用Executors/Streams/Thread类等更好的方法是什么？如果可以使用Streams，请提供一个链接，在那里我可以找到一些关于如何实现这一点的教程。谢谢你的帮助

您可以使用以下模式使用Java流并行处理

List<File> files = ...
files.parallelStream().forEach(f -> process(f));

---

注意：

process

在本例中不能抛出CheckedException。我建议您记录它或返回一个结果对象。

如果您想了解ReactiveX，我建议您使用rxJava Observable.zip

在这里，您可以并行运行多个进程，例如：

 public class ObservableZip {

  private Scheduler scheduler;
  private Scheduler scheduler1;
  private Scheduler scheduler2;

  @Test
  public void testAsyncZip() {
           scheduler = Schedulers.newThread();//Thread to open and read 1 file
           scheduler1 = Schedulers.newThread();//Thread to open and read 1 file
           scheduler2 = Schedulers.newThread();//Thread to open and read 1 file
           Observable.zip(obAsyncString(file1), obAsyncString1(file2), obAsyncString2(file3), (s, s2, s3) -> s.concat(s2)
                                                                                        .concat(s3))
              .subscribe(result -> showResult("All files in one:", result));
       }

       public void showResult(String transactionType, String result) {
           System.out.println(result + " " +
                               transactionType);
       }

       public Observable<String> obAsyncString(File file) {
           return Observable.just(file)
                     .observeOn(scheduler)
                     .doOnNext(val -> {
                        //Here you  read your file
                     });
       }

       public Observable<String> obAsyncString1(File file) {
           return Observable.just(file)
                     .observeOn(scheduler1)
                     .doOnNext(val -> {
                         //Here you  read your file 2

                     });
       }

       public Observable<String> obAsyncString2(File file) {
           return Observable.just(file)
                     .observeOn(scheduler2)
                     .doOnNext(val -> {
                         //Here you  read your file 3

                     });
       }
      }

公共类{
专用调度器；
专用调度器调度器1；
专用调度程序2；
@试验
public-void-testAsyncZip（）{
scheduler=Schedulers.newThread（）；//打开并读取1个文件的线程
scheduler1=Schedulers.newThread（）；//打开并读取1个文件的线程
scheduler2=Schedulers.newThread（）；//打开并读取1个文件的线程
obaservable.zip（obAsyncString（file1）、obAsyncString1（file2）、obAsyncString2（file3）、（s、s2、s3）->s.concat（s2）
康卡特先生（s3））
.subscribe（结果->显示结果（“一个文件中的所有文件：”，结果））；
}
public void showResult（字符串事务类型、字符串结果）{
System.out.println（结果+“”+
交易类型）；
}
公共可观测obAsyncString（文件）{
返回可观察的.just（文件）
.observeOn（调度程序）
.doOnNext（val->{
//这是你的文件
});
}
公共可观测obAsyncString1（文件）{
返回可观察的.just（文件）
.observeOn（附表1）
.doOnNext（val->{
//这是你的文件2
});
}
公共可观测obAsyncString2（文件）{
返回可观察的.just（文件）
.observeOn（附表2）
.doOnNext（val->{
//这是你的文件3
});
}
}

---

就像我说的，以防您想了解ReactiveX，因为如果不想，在堆栈中添加这个框架来解决这个问题会有点过火，而且我更希望以前的流并行解决方案

无论如何，这也很有帮助！！

 public class ObservableZip {

  private Scheduler scheduler;
  private Scheduler scheduler1;
  private Scheduler scheduler2;

  @Test
  public void testAsyncZip() {
           scheduler = Schedulers.newThread();//Thread to open and read 1 file
           scheduler1 = Schedulers.newThread();//Thread to open and read 1 file
           scheduler2 = Schedulers.newThread();//Thread to open and read 1 file
           Observable.zip(obAsyncString(file1), obAsyncString1(file2), obAsyncString2(file3), (s, s2, s3) -> s.concat(s2)
                                                                                        .concat(s3))
              .subscribe(result -> showResult("All files in one:", result));
       }

       public void showResult(String transactionType, String result) {
           System.out.println(result + " " +
                               transactionType);
       }

       public Observable<String> obAsyncString(File file) {
           return Observable.just(file)
                     .observeOn(scheduler)
                     .doOnNext(val -> {
                        //Here you  read your file
                     });
       }

       public Observable<String> obAsyncString1(File file) {
           return Observable.just(file)
                     .observeOn(scheduler1)
                     .doOnNext(val -> {
                         //Here you  read your file 2

                     });
       }

       public Observable<String> obAsyncString2(File file) {
           return Observable.just(file)
                     .observeOn(scheduler2)
                     .doOnNext(val -> {
                         //Here you  read your file 3

                     });
       }
      }