4

我如何计算依赖项.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;
    }
}
4

4 回答 4

3

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

所以可以做这样的事情

public static long count = 0;

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

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

于 2013-06-28T15:55:06.427 回答
1

每个服务已经有一个存储“父”（它所依赖的服务）的列表。因此，该列表的大小是直接父母的数量。由于您还想更进一步并找到间接依赖关系，因此您可以通过“询问”每个父服务它依赖多少服务来做到这一点。

代码看起来像这样：

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将被重复计算。

因此，如果您遇到这种情况，您将不得不修改方法。

于 2013-06-28T16:59:36.197 回答
0

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

添加一个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);
}

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

于 2013-06-28T16:05:21.933 回答
0

只需拥有一个 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++);
    }
  }
于 2018-04-11T10:41:27.177 回答