Java Multi threading - Éviter le traitement des demandes en double

Question

J'ai le scénario d'environnement multi-thread suivant - Les demandes arrivent à une méthode et je veux éviter le traitement en double des demandes concurrentes à venir. Comme plusieurs demandes similaires peuvent être en attente d'être traitées dans l'état bloqué. J'ai utilisé la hashtable pour garder une trace de la requête traitée, mais cela va créer des fuites de mémoire, alors comment garder la trace de la requête traitée et éviter les mêmes requêtes à traiter qui peuvent être en état de blocage. Comment vérifier que toute demande entrante en attente/bloquée n'est pas celle traitée dans les threads actuels.

Answer 1

Si la fuite de mémoire est le problème jetez un oeil à WeakHashMap pour garder votre demande pendant le traitement.

Une autre solution serait d'utiliser un cache mémoire lié ...

Answer 2

D'accord, je pense que je comprends un peu ce que vous voulez.

Vous pouvez utiliser une ConcurrentSkipListSet en tant que file d'attente. Mettre en œuvre vos éléments en file d'attente comme ceci:

class Element implements Comparable<Element> { 
     //To FIFOnize 
     private static final AtomicLong SEQ = new AtomicLong(); 
     private final long id = SEQ.incrementAndGet(); 

     //Can only be executed once. 
     private final Semaphore execPermission = new Semaphore(1); 


     public int compareTo(Element e){ 
      // If element e1 exists on the queue such that 
      // e.compareTo(e1) == 0, that element will not 
      // be placed on the queue. 
      if(this.equals(e)){ 
       return 0; 
      }else{ 
       //This will enforce FIFO. 
       this.id > e.id ? 1 : (this.id < e.id ? -1 : 0); 
      } 
     } 
     //implement both equals and hashCode 

     public boolean tryAcquire(){ 
      return execPermission.tryAcquire(); 
     } 
} 

Maintenant vos fils doivent,

while(!Thread.currentThread().isInterrupted()){ 
    //Iterates from head, therefore simulates FIFO 
    for(Element e : queue){ 
      if(e.tryAcquire()){ 
       execute(e); //synchronous 
       queue.remove(e); 
      } 
    } 
} 

Vous pouvez également utiliser une variante de blocage de cette solution (une SortedSet limitée et laisser les threads de travail bloquer s'il n'y a pas éléments etc.).

Answer 3

Il n'y a aucune raison inhérente au fait que le suivi des demandes dans une HashMap (ou de toute autre manière que vous pourriez choisir) conduirait à des fuites de mémoire. Tout ce qui est nécessaire est un moyen de retirer les entrées une fois qu'elles ont été traitées.

Cela pourrait signifier avoir vos threads de traitement de demande:

• supprimer directement l'entrée;
• communiquer de nouveau au répartiteur; ou
• marquer la demande comme traitée, donc que le répartiteur peut supprimer les entrées.