java - 如何做好服务经理？

Question

我需要制作一个包含 4 个服务(示例 A、B、C 和 D)的服务管理器，加载服务列表。服务需要有 start() 和 stop() 方法，它们按以下顺序相互依赖:

• 服务B和C依赖于服务A

• 服务D依赖于服务B

由此可以推断出:

• 要启动服务D，需要启动服务A和B

• 要停止服务A，必须先停止服务B、D、C

• 服务 B 和 C 可以在 A 启动后立即并行启动。相反，它们可以并行停止。

这是我的代码，它无法正常工作。问题是它按顺序启动服务，但只是因为我将它们按顺序放在列表中。我弄得一团糟。我需要帮助，因为现在我不知道如何使用我评论过的这条线，也不知道如何停止它。感谢您的帮助!

public class CountDown {

    public static void main(String args[]) {

        List<String> Services = Collections.synchronizedList(new ArrayList<String>());
        Services.add("Services A");
        Services.add("Services B");
        Services.add("Services C");
        Services.add("Services D");


       final CountDownLatch Start = new CountDownLatch(4);
       final CountDownLatch Stop = new CountDownLatch(4);

    new Thread(new Service("Service A", 1000, Start, Stop, Services)).start();
    new Thread(new Service("Service B", 2000, Start, Stop, Services)).start();
    new Thread(new Service("Service C", 3000, Start, Stop, Services)).start();
    new Thread(new Service("Service D", 4000, Start, Stop, Services)).start();

    /* A.start(); // this is how it should work

      if (A.isAlive())
      {
          B.start();
          C.start();
      }

      if(B.isAlive() && A.isAlive())
      {
          D.start();
      }

      D.interrupt();
      if(D.isInterrupted())
      {
          B.interrupt();
          C.interrupt();

      }
      if(B.isInterrupted() && D.isInterrupted())
      {
          A.interrupt();
      }*/



      try { 
          Start.await();
          Stop.countDown();   
    } catch(InterruptedException ie){
        ie.printStackTrace();
    }

    }

}



class Service implements Runnable{

    List<String> list;
    private final String name;
    private final int time;
    private final CountDownLatch Stop;
    private final CountDownLatch Start;


    public Service(String name, int time, CountDownLatch Start, CountDownLatch Stop, List<String> list){
        this.name = name;
        this.time = time;
        this.Start = Start;
        this.Stop = Stop;

        this.list = list;
    }

    @Override
    public void run() {


        try {


            Start.countDown();
           Thread.sleep(time);    
            list.add(name);


            System.out.println( name + " is Up!");


           Stop.await();

        } catch (InterruptedException ex) {
            Logger.getLogger(Service.class.getName()).log(Level.SEVERE, null, ex);
        }


    }

}

Answer 1

如果你想让它成为一个通用的相互依赖的服务系统，你需要在关于服务的元数据中捕获依赖关系。让我们假设您有以下可用于每项服务的数据:

List<String> getPredecessors();

返回在此服务启动之前必须运行的所有服务的名称。然后你有一组已经启动的服务:

Set<String> startedServices = new HashSet<String>();

for ( String service: Services ) {
    boolean allClear = true;
    for ( String predecessor: Service(service).getPredecessors() ) {
        if ( ! startedServices.contains(predecessor) ) {
            allClear = false;
            break;
        }
    }
    if ( allClear ) {
        // start the service
        new Thread(new Service(service, 1000, Start, Stop, Services)).start();
        startedServices.add(service);
    }
}

只有当它需要的所有服务都在运行时，这才会启动一个服务。现在您需要遍历所有服务，直到它们都在运行(否则您会发现死锁)。

停止服务是相反的问题。您可以在启动时从前任列表中计算出后继列表。在后继列表上使用相同的算法。