计算方法调用次数

Question

如何计算可能的次数是多少次dependency.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

如果我理解正确的问题，下面应该工作。

添加一个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 3

每个服务已经有一个存储“父”（它所依赖的服务）的列表。所以，该清单的大小是父母的直接的计数。既然你还想进一步寻找间接依赖关系，你可以通过“询问”每个父服务它依赖于多少服务来完成。

的代码会是这个样子：

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); 

现在，一个在两个方面是“大父” d的。因此，如果您调用D上的getCountOfDependencies（），它将计算直接父级（B和C），并会要求每个人报告其依赖关系。他们将分别报告1，因此A将被重复计数。

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