有两个不同的接口实现在不同的线程上执行

Question

我有一个接口说VegetableCreation 有一个方法：

public void writeVeggieDataIntoFile();

还有两个不同的类Apple 和Mango 实现VegetableCreation。

还有一个工厂类 VegetableFactory 和 create() 方法：

public class VegetableFactory {
    public VegetableCreation create(String arg0) {

        if (arg0.equals("Apple"))
           return new Apple();
        else if (arg0.equals("Mango")
           return new Mango();
        else {
           // create and return both apple and mango by spawning two different threads
           // so that the writeVeggieDataIntoFile();  gets invoked concurrently
           // for both apple and mango and two different file is created
        }
    }
}

我在这里基本上想要实现的是，当我从客户端类的main() 方法调用VegetableFactory 类的create() 方法并传递除"Apple" 或"Mango" 以外的任何字符串值作为运行时参数。我希望两个不同的线程在每个 Apple 和 Mango 对象上工作，并在每个 writeVeggieDataIntoFile() 方法上同时工作。

任何关于设计策略/或使用哪些并发 API 等的建议都将受到高度赞赏。

P.S.：我应该叫它水果**而不是蔬菜*

Answer 1

查看 Composite 模式，然后构建一个 CompositeVegetable，当被告知“做这件事”时，它会启动两个线程，一个做一件事，另一个做另一件事。

public class BothVegetable implements Vegetable {
    public void writeVeggieDataInfoFile() {
        Thread thread1 = new Thread(new AppleRunnable());
        Thread thread2 = new Thread(new MangoRunnable());
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
}

// and in your factory

    return new CompositeVegetable();

PS。你的蔬菜在我看来就像水果！

Answer 2

我希望从名为VegetableFactory/FruitFactory 的工厂获得Vegetable/Fruit，而不是VegetableCreation/FruitCreation。

我会避免线程创建和文件写入作为工厂方法中的副作用。

我还将writeFruitDataIntoFile() 重命名/更改为write(Writer out)，因为您所写的内容由封闭的接口或类告知，而您写入的位置由其方法参数告知。

如果你真的需要并发处理，在write(...)中创建一个线程，让工厂方法简单地返回一个Fruit。

优点是：

• 在创建对象时没有必须记录的副作用。
• 线程仅按需创建（以防write() 被调用），而不是在每次Fruit 对象创建时创建。
• 您不需要额外的课程。
• 了解工厂设计模式的每个人都一眼就能理解它的简洁实现。

见：

• Factory (object-oriented programming)
• Factory method pattern
• Abstract factory pattern

为了良好的 OO 实践，我会使用接口：

interface Fruit {

  void write(Writer out);

  ...
}  // Fruit

它的抽象实现：

public abstract class AbstractFruit implements Fruit {

  Data data;

  public void write(Writer out) {
    ...
  }

  ...
}  // AbstractFruit

 

public classe Apple extends AbstractFruit implements Fruit {
  ...
}

 

public classe Mango extends AbstractFruit implements Fruit {
  ...
}

为了type safety，我会使用特定的get...() 方法（通常是done in the Java API）：

public class FruitFactory {

  public static Fruit getApple() {
     Fruit a = new Apple()
     ...
     return a;
  }

  public static Fruit getMango() {
     Fruit m = new Mango()
     ...
     return m;
  }
}  // FruitFactory

或enum：

interface Fruit {

  enum Type {
    APPLE,
    MANGO 
  }

  void write(Writer out);

  ...
}  // Fruit

 

public class FruitFactory {

  public static Fruit get(Fruit.Type fruitType) {

     switch (fruitType) {
        case Fruit.Type.APPLE:
          Fruit a = new Apple()
          ...
          return a;
          break;
        case Fruit.Type.MANGO:
          Fruit m = new Mango()
          ...
          return m;
          break;
        default:
          throw new FruitTypeNotSupported/* Runtime, i.e. unchecked */Exception();
          break; 
     }
  }  // get(...)
}  // FruitFactory

请参阅RuntimeException 的 API 文档：

未经检查的异常不需要在方法中声明 [...] throws 子句

Answer 3

首先我会让你的工厂有静态创建。然后在create do item instanceof Fruit中再创建fruit线程。 else if item instanceof Vegetable 然后做蔬菜线程。