计算方法被调用了多少次

Question

How can I count how many times is dependency.startService(); method call? Different Services are calling this method and I don't want to get how many time did everyone call that method but single Service. I should get this output :

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

Actually this number should mean how many services these two are depending on. Do you have any ideas on how can I do this? I have tried and I can only get a global number of calling that method which is 3.

Here is my code:

 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

You can set a variable count . For each method call increase the value by one. If you want to access the variable from outside of the class you can set it public static.

So something like this can be done

public static long count = 0;

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

When you need to check you can check the count variable.

Answer 2

Each Service already has a List that stores the "parent" (services on which it is dependent). So, the size of that list is the count of direct parents. Since you also want to go further and find indirect dependencies, you can do it by "asking" each parent service how many services it depends upon.

The code would look something like this:

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

Warning! This will not work if a service can be dependent on another service via two or more "paths". For instance, consider this scenario:

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

Now, A is a "grand-parent" of D in two ways. So, if you call getCountOfDependencies() on D , it will count the direct parents ( B and C ) and will ask each of those to report their dependencies. They will each report 1, and thus A will be double-counted.

So, if you can have that type of situation, you will have to modify the approach.

Answer 3

If I understand the question correctly, the following should work.

Add an ArrayList<String> dependentServices as a class member.

Change startService() to startService(String callerName) .

When starting a service, for example serviceA, call serviceA.startService(serviceName);

In your startService(...) method add the following:

boolean dependent = false;

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

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

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

In each service, the ArrayList dependentServices will now keep a list of the names of the services which have called it. The size of the ArrayList will tell you how many services there are.

Answer 4

Simply have a StaticCounter class and use that for identifying counts by incrementing the values.

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