Problème dans le sémaphore étant interrompu plusieurs fois

Question

J'ai un sémaphore qui limite les utilisateurs à télécharger n nombre de fichiers à la fois. Chaque fichier est téléchargé dans un fil séparé.

EDIT: l'exemple modifié de sorte que la libération se produise correctement

import java.util.concurrent.Semaphore; 
public void downloadFile() { 
    Thread downloadThread = new Thread() { 
     boolean bSemaphoreAcquired = false; 
     public void run() { 
      try { 
       semaphore.acquire(); 
       bSemaphoreAcquired = true; 
       // do the download 
      } catch (InterruptedException e) { 
      } finally { 
       if (bSemaphoreAcquired) semaphore.release(); 
      } 
     } 
    }; 
    // add download thread to the list of download threads 
    downloadThread.start(); 
} 

Maintenant, tous les nouveaux téléchargements attendront les téléchargements précédents pour terminer une fois que tous les permis de sémaphores ont été acquis.

Lorsque l'utilisateur choisit d'annuler un téléchargement en attente à l'appel d'acquisition, j'appelle la méthode interruption() pour terminer ce fil de téléchargement. Le problème auquel je suis confronté est qu'une fois que ce sémaphore a été interrompu, il ne jetterait pas l'exception InterruptedException la deuxième fois !! Tout nouveau thread créé attendra la méthode acquérir pour toujours!

Sequence of events (Semaphore that permits 2 threads) 
- thread 1 downloading 
- thread 2 downloading 
- thread 3 waiting on acquire() 
- thread 3 is cancelled (interrupt() is called). InterruptedException is thrown and the thread exits 
- thread 4 is created and is now waiting on acquire() 
- thread 4 is cancelled (interrupt() is called). InterruptedException IS NOT THROWN ANYMORE!!! 

Ceci est la trace de la pile de fil 4

Semaphore$FairSync(AbstractQueuedSynchronizer).fullGetFirstQueuedThread() line: 1276  
Semaphore$FairSync(AbstractQueuedSynchronizer).getFirstQueuedThread() line: 1232  
Semaphore$FairSync.tryAcquireShared(int) line: 201 
Semaphore$FairSync(AbstractQueuedSynchronizer).acquireSharedInterruptibly(int) line: 1142 
Semaphore.acquire() line: 267 
FileDownloadManager$1.run() line: 150 

Pourquoi fil 4 reçoit pas l'exception?

Answer 1

Je suggère d'utiliser un pool de threads standard au lieu de sémaphores. Le problème avec votre solution est que vous créez un nouveau thread indépendamment du fait que vous ayez atteint la limite maximale ou non. Donc, si vous avez 1000 demandes simultanées, vous allez créer 1000 threads, ce qui est vraiment inutile.

Essayez plutôt quelque chose comme ceci:

ExecutorService executorService = Executors.newFixedThreadPool(5); 
    executorService.submit(new Runnable() { 
     public void run() { 
      // do download 
     } 
    }); 

Answer 2

Libérez-vous le sémaphore dans la capture? Pourquoi ne pas mettre le try-catch dans l'aquire-release? Je ne sais pas ce que java fait, mais ce ne serait pas plus logique. De cette façon, tout problème au sein de l'essai ... catch se termine toujours par la libération du sémaphore.