Comment puis-je gérer quels éléments sont dans le ThreadPool?

Question

J'ai un service Windows qui exécute une méthode lorsque le délai principal des services est écoulé (OnElapse).

La méthode OnElapse obtient une liste de fichiers .xml à traiter. Chaque fichier xml est inséré dans un ThreadPool.

Je veux m'assurer que je n'insère pas 2 XML avec le même nom dans le ThreadPool.

Comment puis-je gérer quels éléments sont dans le ThreadPool? Je veux essentiellement faire ceci:

if xmlfilename not in threadpool 
    insert in threadpool 

Answer 1

Ceci est assez astucieux car vous devez surveiller de près le ThreadPool et cela nécessitera une forme de synchronisation. Voici un exemple rapide et sale d'un moyen de le faire.

class XmlManager { 
    private object m_lock = new object(); 
    private HashSet<string> m_inPool = new HashSet<string>(); 

    private void Run(object state) { 
    string name = (string)state; 
    try { 
     FunctionThatActuallyProcessesFiles(name); 
    } finally { 
     lock (m_lock) { m_inPool.Remove(name); } 
    } 
    } 

    public void MaybeRun(string xmlName) { 
    lock (m_lock) { 
     if (!m_pool.Add(xmlName)) { 
     return; 
     } 
    } 
    ThreadPool.QueueUserWorkItem(Run, xmlName); 
    } 
} 

Ceci n'est pas une solution infaillible. Il y a au moins une condition de concurrence dans le code. A savoir qu'un élément pourrait être retiré du pool pendant que vous essayez de le rajouter et qu'il ne sera pas réellement ajouté. Mais si vous êtes seulement concerné par leur traitement une seule fois, cela n'a pas d'importance.

Answer 2

OnElaspe ne peut pas renommer le fichier xml? donc il a un nom unqiue sur le pool de threads. Vous ne pourriez pas faire un dictionnaire> et vérifier cela avant de faire l'insertion?

Answer 3

Quelque chose comme ça ...

Dictionary<ThreadPool, List<String>> poolXmlFiles = new Dictionary<ThreadPool, List<String>>(); 
if(poolXmlFiles.ContainsKey(ThreadPool) && !poolXmlFiles[ThreadPool].Contains(xmlFileName)) 
{ 
    poolXmlFiles[ThreadPool].Add(xmlFileName); 
    //Add the xmlFile to the ThreadPool 
} 

Désolé s'il y a des erreurs de syntaxe, je code en VB ces jours-ci.

Answer 4

Quelque chose comme ça devrait le faire (utiliser un HashSet au lieu d'un dictionnaire si vous utilisez .Net 3.5 ou supérieur):

using System; 
using System.Collections.Generic; 
using System.Threading; 

namespace Something 
{ 
    class ProcessFilesClass 
    { 
     private object m_Lock = new object(); 
     private Dictionary<string, object> m_WorkingItems = 
      new Dictionary<string, object>(); 
     private Timer m_Timer; 

     public ProcessFilesClass() 
     { 
      m_Timer = new Timer(OnElapsed, null, 0, 10000); 
     } 

     public void OnElapsed(object context) 
     { 
      List<string> xmlList = new List<string>(); 
      //Process xml files into xmlList 

      foreach (string xmlFile in xmlList) 
      { 
       lock (m_Lock) 
       { 
        if (!m_WorkingItems.ContainsKey(xmlFile)) 
        { 
         m_WorkingItems.Add(xmlFile, null); 
         ThreadPool.QueueUserWorkItem(DoWork, xmlFile); 
        } 
       } 
      } 
     } 

     public void DoWork(object xmlFile) 
     { 
      //process xmlFile 
      lock (m_Lock) 
      { 
       m_WorkingItems.Remove(xmlFile.ToString()); 
      } 
     } 
    } 
}