Question

我已经在这7天里一直在努力。非常感谢您的见解。

考虑框架代码。

final class Main {
 // assuming programmerCode was injected
 Interface inter = (Interface) programmerCode;
 inter.doProcess();
}

interface Interface {
 void doProcess();
}

abstract ProgramApp implements Interface {
 public void doProcess() { 
  for (File file : files) {
   foo(file);
   bar(file);
  }
 }

 public abstract void foo(File file);
 public abstract void bar(File file);
}

abstract Program extends ProgramApp {
 public final void doProcess() { }
}

以及使用它的代码，

class ProgrammerCode extends Program {

 File file;
 String a1;
 String a2;

 public void foo(File file) {
  // read file per line store in a1
 }

 public void bar(File file) {
  // read file per line and append somestring and store in a2 
 }
}

目前，该程序会串行处理文件。关于如何使这个程序并行处理文件而不触及ProgrammerCode的任何建议？

目标：应使用ProgrammerCode中的方法实现并行独立处理每个文件，而无需对其进行修改。修改应该在框架代码中的某处完成。

我真的不知道在哪里放置线程部分。我的假设是它应该在文件循环中，但我不知道它是否是线程安全的，因为我将使用ProgrammerCode中定义的方法。

Answer 1

一种选择是注入ProgrammerCode 提供商而不是实际的ProgrammerCode。然后，您可以为每个文件创建一个实例，并并行执行这些实例。 ProgrammerCode的每个实例只能在一个线程中使用。

Answer 2

无论你做什么，ProgrammerCode的实现者都可以编写错误的代码，特别是线程不安全的代码。您可以做的最好的事情是尝试简化实施者必须遵循的规则。

因此Jon建议使用一个简单的规则，每个File一个ProgrammerCode很有意义。然后告知实现者他为每个文件都有一个ProgrammerCocde实例，并且他们负责实例之间的任何交互。

Answer 3

我的建议是让文件处理完全独立。这完全消除了多线程问题，并允许扩展/实现接口而不关心并发性。您可以使用java.util.concurrent的ThreadPoolExecutor并行执行文件任务。

伪代码看起来像这样：

main（）{

档案文件; ThreadPoolExecutor池;

for（文件文件：files）{ pool.execute（new Runnable（）{ 跑（） { 接口inter =（接口）programmerCode; inter.doProcess（文件）; } }）; }

Answer 4

abstract ProgramApp implements Interface {
 public void doProcess() { 
  for (File file : files) {
   new Thread(
      new Runnable() {
        public void run() {
             foo(file);
             bar(file);
        }
      }).start();
  }
 }

如何保证重载方法的线程安全？

4 个答案: