compter combien de fois, c'est la méthode appelée

Comment puis-je compter combien de fois est la dépendance.startService(); l'appel de la méthode? Différents Services sont à l'appel de cette méthode et je ne veux pas combien de fois avez-tout le monde l'appel de la méthode, mais un seul Service. Je devrais obtenir ce résultat :

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

En fait, ce nombre devrait dire sur la façon dont de nombreux services de ce deux sont en fonction.
Avez-vous des idées comment puis-je faire cela?
J'ai essayé et je ne peux obtenir le nombre global de l'appel de cette méthode sorcière est 3.

Voici mon 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;
}
}
Il n'est pas nécessaire d'ajouter le majeur de la balise dans le titre.
Pourquoi dites-vous "D" doit être 2? Est-ce parce que D dépend de B et que B dépend de A? Voulez-vous parcourir la liste des dépendances de cette façon?
oui je vais essayer d'obtenir ce nombre comme ça. Pensez-vous que ce n'est pas la bonne façon?

OriginalL'auteur njamanjam | 2013-06-28

  1. 3

    Vous pouvez définir une variable count. Pour chaque appel de méthode, d'augmenter la valeur de un. Si vous souhaitez accéder à la variable à partir de l'extérieur de la classe, vous pouvez le configurer public static.

    Donc quelque chose comme ceci peut être fait

    public static long count = 0;
public Service startService() throws InterruptedException
{
cout++;
//method tasks
}

    Lorsque vous devez vérifier vous pouvez vérifier l' count variable

    J'ai déjà fait, et cela ne fonctionne pas, je suis sortie comme ceci: Service de Service de C permet de commencer! 1 Service D permet de commencer! 1 1 et je devrais dans ce Service D 2 1 1
    Le faire avec un AtomicInteger - hackety hack hack. 🙂
    la réponse ci-dessus est correct, comment faites-vous appel à la cout++ dans votre programme?
    i-m de l'utiliser comme ceci: for(dépendance de Service : dependentServicesOn) { if(!la dépendance.isStarted()) { compteur++; dépendance.startService(); } System..println(compteur); }
    c'est si simple, mais je juste ne sais pas comment obtenir le numéro 2 XD je ne sais pas ce que je fais mal...

    OriginalL'auteur stinepike

  2. 1

    Chaque Service dispose déjà d'une Liste de magasins "parent" (les services dont il dépend). Ainsi, la taille de cette liste est le nombre de direct parents. Puisque vous aussi vous voulez aller plus loin et de trouver indirects dépendances, vous pouvez le faire par "demander" à chaque parent de service comment de nombreux services dont il dépend.

    Le code devrait ressembler à quelque chose comme ceci:

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

    Avertissement! Cela ne fonctionnera pas si un service peut être dépendant d'un autre service, soit par deux ou plusieurs "chemins". Par exemple, considérez le scénario suivant:

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

    Maintenant, Un est un "grand-mère" de D de deux façons. Donc, si vous appelez getCountOfDependencies() sur D, il comptera les parents directs (B et C) et demander à chacun de ceux qui, au rapport de leurs dépendances. Ils feront chacun un rapport 1, et donc Un seront comptés en double.

    Donc, si vous pouvez avoir ce type de situation, vous aurez à modifier l'approche.

    OriginalL'auteur Darius X.

  3. 0

    Si je comprends correctement à la question, la suivante devrait fonctionner.

    Ajouter un ArrayList<String> dependentServices en tant que membre de la classe.

    Changement startService() à startService(String callerName).

    Lors du démarrage d'un service, par exemple serviceA, appel serviceA.startService(serviceName);

    Dans votre startService(...) la méthode ajouter les éléments suivants:

    boolean dependent = false;
for(int i = 0; i < dependentServices.size(); i++) {
if(dependentServices.get(i).equals(callerName) {
dependent = true;
}
}
if(!dependent) {
dependentServices.add(callerName);
}

    Dans chaque service, la liste de tableaux dependentServices va maintenant faire une liste des noms des services qui l'ont appelé. La taille de la liste de tableaux vous dira combien de services il y a des.

    OriginalL'auteur MaxAlexander

  4. 0

    Tout simplement une StaticCounter classe et l'utiliser pour l'identification de compte par incrémentation de la valeur.

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

    OriginalL'auteur Ganesa Vijayakumar