Problème de synchronisation avec ManualResetEvent

Question

J'ai écrit une méthode qui télécharge des fichiers, et maintenant j'essaie de le faire télécharger jusqu'à 5 fichiers en parallèle, et pour le reste d'attendre que les précédents se terminent. J'utilise un ManualResetEvent pour cela, mais quand j'inclus la partie de syncronisation, il ne télécharge plus rien (sans que cela fonctionne).

Voici le code des méthodes:

static readonly int maxFiles = 5; 
    static int files = 0; 
    static object filesLocker = new object(); 
    static System.Threading.ManualResetEvent sync = new System.Threading.ManualResetEvent(true); 

    /// <summary> 
    /// Download a file from wikipedia asynchronously 
    /// </summary> 
    /// <param name="filename"></param> 
    public void DoanloadFileAsync(string filename) 
    { 
     ... 
     System.Threading.ThreadPool.QueueUserWorkItem(
      (o) => 
      { 
       bool loop = true; 
       while (loop) 
        if (sync.WaitOne()) 
         lock (filesLocker) 
         { 
          if (files < maxFiles) 
          { 
           ++files; 
           if (files == maxFiles) 
            sync.Reset(); 
           loop = false; 
          } 
         } 
       try 
       { 
        WebClient downloadClient = new WebClient(); 
        downloadClient.OpenReadCompleted += new OpenReadCompletedEventHandler(downloadClient_OpenReadCompleted); 
        downloadClient.OpenReadAsync(new Uri(url, UriKind.Absolute)); 
        //5 of them do get here 
       } 
       catch 
       { 
        lock (filesLocker) 
        { 
         --files; 
         sync.Set(); 
        } 
        throw; 
       } 
      }); 
    } 

    void downloadClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e) 
    { 
     try 
     { 
      //but none of the 5 get here 
      ...Download logic... //works without the ManualResetEvent 
     } 
     finally 
     { 
      lock (filesLocker) 
      { 
       --files; 
       sync.Set(); 
      } 
     } 
    } 

que je fais quelque chose de mal?

Il est écrit avec Silverlight 4 pour Windows Phone 7.

Edit: Il n'y a pas Sémaphore ou SemaphoreSlim dans Silverlight 4.

Answer 1

Ce que je voulais dire dans mon commentaire était tout en utilisant un lent lock lorsque vous pouvez utiliser Interlocked. En outre, il sera beaucoup plus performant de cette façon.

au plus 5 téléchargements actifs en parallèle:

public class Downloader 
{ 
private int fileCount = 0; 
private AutoResetEvent sync = new AutoResetEvent(false); 

private void StartNewDownload(object o) 
{ 
    if (Interlocked.Increment(ref this.fileCount) > 5) this.sync.WaitOne(); 

    WebClient downloadClient = new WebClient(); 
    downloadClient.OpenReadCompleted += downloadClient_OpenReadCompleted; 
    downloadClient.OpenReadAsync(new Uri(o.ToString(), UriKind.Absolute)); 
} 

private void downloadClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e) 
{ 
    try 
    { 
    // Download logic goes here. 
    } 
    catch {} 
    finally 
    { 
    this.sync.Set(); 
    Interlocked.Decrement(ref this.fileCount); 
    } 
} 

public void Run() 
{ 
    string o = "url1"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 
    Thread.Sleep(100); 

    o = "url2"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 

    o = "url3"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 
    Thread.Sleep(200); 

    o = "url4"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 

    o = "url5"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 

    o = "url6"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 

    o = "url7"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 
    Thread.Sleep(200); 

    o = "url8"; 
    System.Threading.ThreadPool.QueueUserWorkItem(this.StartNewDownload, o); 
    Thread.Sleep(400); 
} 
} 

Answer 2

Au REGARDENT WaitOne() est frappé avant que vous créez le WebClient. Puisque tout le code qui appelle Set() se trouve dans le gestionnaire d'événements ou dans le gestionnaire d'exceptions, il ne sera jamais touché.

Peut-être vous par erreur inclus le code WebClient dans le pool de threads méthode de fil qui devrait être à l'extérieur de celui-ci

System.Threading.ThreadPool.QueueUserWorkItem(
     (o) => 
     { 
      bool loop = true; 
      while (loop) 
       if (sync.WaitOne()) 
        lock (filesLocker) 
        { 
         if (files < maxFiles) 
         { 
          ++files; 
          if (files == maxFiles) 
           sync.Reset(); 
          loop = false; 
         } 
        } 

     }); 

//Have the try catch OUTSIDE the background thread. 
      try 
      { 
       WebClient downloadClient = new WebClient(); 
       downloadClient.OpenReadCompleted += new OpenReadCompletedEventHandler(downloadClient_OpenReadCompleted); 
       downloadClient.OpenReadAsync(new Uri(url, UriKind.Absolute)); 
       //5 of them do get here 
      } 
      catch 
      { 
       lock (filesLocker) 
       { 
        --files; 
        sync.Set(); 
       } 
       throw; 
      } 

Answer 3

Il semble que vous essayez de limiter le nombre de threads qui peuvent entrer dans votre section critique, le téléchargement du fichier, à la fois. Plutôt que d'essayer de le faire à la main, utilisez un System.Threading.Semaphore - c'est ce qu'il fait!