verrouillage sur plusieurs méthodes que si un fil est dans une certaine méthode

Question

J'ai une classe (exemple simplifié) comme:

public class SomeCollection : ICloneable 
{ 
    public void Add(Item item) { /* ... */ } 
    public void Remove(Item item) { /* ... */ } 
    public Item Get(Key key) { /* ... */ } 
    /* 
    ... 
    */ 
    public object Clone() { /* ... */ } 
} 

J'ai besoin que lorsqu'un fil entre clone() aucun autre thread ne peut entrer dans Ajouter ou Supprimer mais peut entrer dans Get. Au début, je pensais:

public void Add(Item item) { lock(addLock) { /* ... */ } } 
    public void Remove(Item item) { lock(removeLock) { /* ... */ } } 

    public object Clone(Item item) 
    { 
     lock(addLock) 
     { 
      lock(removeLock) 
      { 
       /* ... */ 
      } 
     } 
    } 

Cela fonctionne (je pense), mais présente certains inconvénients: * Je ne veux pas entrer dans deux fils Ajouter à bloquer une autre - je traite que plus profondément dans le code * Je vais devoir supporter les frais généraux de verrouillage pour chaque appel à Ajouter ou supprimer

Alors je pensais de cette

private volatile bool cloning = false; // notice the volatile keyword 

    public void Add(Item item) 
    { 
     int i = 0; 
     while(cloning) 
     { 
      if (i++ > 20) 
       throw new TimeoutException(); 
      Thread.Sleep(50); // waits 50 milliseconds 
     } 
     /* ... */ 
    } // and the same for Remove 

    public object Clone() 
    { 
     cloning = true; 
     try 
     { 
      /* do the cloning */ 
     } finally { cloning = false; } 
    } 

Cependant cette approche:

• est plus complexe
• Clone peut entrer alors qu'un fil n'a pas fini d'exécuter Ajouter ou supprimer
• ne paraît pas naturel

J'ai donné ReadWriterLockSlim un bref regard, mais ne semble pas cadrer mon scénario. J'ai besoin de cela parce que la méthode Clone prend du temps (peut prendre plus d'une seconde - la collection est ÉNORME) et une altération dans ce temps va faire exploser l'énumérateur (utilisé dans une boucle foreach). Oui, je dois utiliser foreach puisque la collection de clés sous-jacente n'expose pas autre chose qu'un IEnumerable.

Quoi de neuf recommandez-vous?

Answer 1

Pourriez-vous expliquer pourquoi ReaderWriterLockSlim ne correspond pas à votre scénario? Bien sûr, vous ne l'utiliserez pas pour son usage classique, mais considérez la méthode Clone comme votre rédacteur et les méthodes d'ajout/suppression comme vos lecteurs et je pense que cela convient.

[edit] Une autre chose: Si vous suivez cette route, assurez-vous de documenter pourquoi vous utilisez ReaderWriterLockSlim 'en arrière' afin que la prochaine personne qui lit le code (ou vous dans six mois) comprenne ce qui se passe.