Question

我如何计算时间是多少依赖.startService（）;方法调用？不同的服务正在调用这种方法，我不想知道每个人如何调用该方法，但单个服务。我应该得到这个输出：

My name is Service B and i'm depending on Service A
My name is Service C and i'm depending on Service A
My name is Service D and i'm depending on Service B

***Service Service C lets start!***
   1

***Service Service D lets start!***
   2

实际上这个数字应该意味着这两个服务所依赖的服务数量。你有什么想法我怎么能这样做？我已经尝试了，我只能得到全球号码，这个方法女巫是3。

这是我的代码：

 ManagerService.java
    import java.util.*;
    import java.util.concurrent.CountDownLatch;

    public class ManagerService
    {
        public static void main(String[] args) throws InterruptedException
        {
            //Creating Services
            Service serviceA = new Service("Service A", "Thread A");
            Service serviceB = new Service("Service B", "Thread B");
            Service serviceC = new Service("Service C", "Thread C");
            Service serviceD = new Service("Service D", "Thread D");

            serviceB.dependesOn(serviceA);
            serviceC.dependesOn(serviceA);
            serviceD.dependesOn(serviceB);    

            System.out.println();
            System.out.println("***Service " + serviceC.serviceName +" lets start!***");
            serviceC.startService();
            System.out.println();
            System.out.println("***Service " + serviceD.serviceName +" lets start!***");
            serviceD.startService();

        }
    }

and 
Service.java

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

public class Service
{
    public String serviceName;
    public String threadName;
    private boolean onOrOff = false;
    public List <Service> dependentServicesOn = new ArrayList <Service>();
    public CountDownLatch startSignal;
    private Integer counter = 0;
    public Service(String service_name, String thread_name)
    {
        this.serviceName = service_name;
        this.threadName = thread_name;
    }

    public void dependesOn(Service s) throws InterruptedException
    {
        System.out.println("My name is " + serviceName +" and i'm depending on " + s.serviceName);
        dependentServicesOn.add(s);   
    }

    public Service startService() throws InterruptedException
    {
        for(Service dependency : dependentServicesOn) {
            if(!dependency.isStarted()) {
                dependency.startService();
            }
        }

        startSignal = new CountDownLatch(1);
       // new Thread(new CreateThread(this,startSignal)).start();
        startSignal.countDown();
        return null;
    }

    public boolean isStarted()
    {
        return onOrOff;
    }

    public void setStarted()
    {
        onOrOff = true;
    }
}

Answer 1

您可以设置变量count。对于每个方法调用，将值增加1。如果要从类外部访问变量，可以将其设置为public static。

所以可以这样做

public static long count = 0;

public Service startService() throws InterruptedException
    {
       cout++;
       // method tasks
    }

当您需要检查时，您可以查看count变量

Answer 2

每个服务都有一个存储“父”的列表（它所依赖的服务）。因此，该列表的大小是直接父项的数量。由于您还想进一步寻找间接依赖关系，您可以通过“询问”每个父服务所依赖的服务来实现它。

代码看起来像这样：

public int getCountOfDependencies()
{
   int theCount = 0;

   for (Service nxtService : dependentServicesOn)
   {
      theCount++; //Add one for the "direct parent"

      theCount += nxtService.getCountOfDependencies();  //Also add grand-parents etc.
   }
   return theCount;
}

警告！如果服务可以通过两个或多个“路径”依赖于其他服务，则无效。例如，请考虑以下情况：

serviceB.dependesOn(serviceA);
serviceC.dependesOn(serviceA);
serviceD.dependesOn(serviceB);
serviceD.dependesOn(serviceC);

现在， A 在两个方面是 D 的“祖父母”。所以，如果你在 D 上调用getCountOfDependencies（），它会计算直接父母（ B 和 C ），并会询问每个人报告他们的依赖关系。他们每人报告1，因此 A 将被重复计算。

所以，如果你有这种情况，你将不得不修改方法。

Answer 3

如果我正确理解了这个问题，以下内容应该有效。

添加ArrayList<String> dependentServices作为班级成员。

将startService()更改为startService(String callerName)。

启动服务时，例如serviceA，请致电serviceA.startService(serviceName);

在startService（...）方法中添加以下内容：

boolean dependent = false;

for(int i = 0; i < dependentServices.size(); i++) {

    if(dependentServices.get(i).equals(callerName) {
        dependent = true;
    }
}

if(!dependent) {
    dependentServices.add(callerName);
}

在每个服务中，ArrayList dependentServices现在将保留已调用它的服务名称列表。 ArrayList的大小将告诉你有多少服务。

Answer 4

只需拥有一个StaticCounter类，并使用它来通过递增值来识别计数。

StaticCounter.java

public class StaticCounter {
  static int COUNTER;
}

JTry.java

public class JTry {
  public static void main(String[] args) {
    for(int i = 0; i<5; i++) {
      System.err.println("Passing checkpoint " + StaticCounter.COUNTER++);
    }
  }

计算方法调用的次数

4 个答案: