計算方法調用次數

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將被重複計數。

所以，如果你有這種類型的情況，你將不得不修改方法。