有一个接口两种不同的实现在不同的线程中执行

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

首先我会对你的工厂有静态创建。然后在Create do item instanceof Fruit中创建水果线程。否则，如果项目instanceof蔬菜然后做蔬菜线程。

Answer 3

我希望得到从工厂Vegetable/Fruit称为VegetableFactory/FruitFactory，而不是一个VegetableCreation/FruitCreation。

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

我还重命名/改变writeFruitDataIntoFile()到write(Writer out)，因为你写的东西被封闭接口或类，并在那里你写由其方法参数（S）告诉告诉。

如果您确实需要并发处理，请在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文档：

未检查异常不需要在方法声明[ ...]抛出子句