Accès à la même chaîne (StringBuilder) à l'aide multi-thread

Question

Mon problème est si j'utilise multi-thread sur la même chaîne parfois

la chaîne ne sera pas remplacer. (Je l'ai écrit ceci sur le bloc-notes si la syntaxe peut être

mal)

utilisant System.Thread ... D'autres ofcourse

class .... 
{ 
    private static StringBuild container = new StringBuilder(); 

    static void Main(...) 
    { 
    container.Append(Read From File(Kind of long)); 
    Thread thread1 = new Thread(Function1); 
     Thread thread2 = new Thread(Function2); 
    thread1.Start(); 
    thread2.Start(); 
    //Print out container 
    } 

    static void Function1 
    { 
    //Do calculation and stuff to get the Array for the foreach 
    foreach (.......Long loop........) 
    { 
    container.Replace("this", "With this") 
    } 
    } 
    //Same goes for function but replacing different things. 
    static void Function2 
    { 
    //Do calculation and stuff to get the Array for the foreach 
    foreach (.......Long loop........) 
    { 
    container.Replace("this", "With this") 
    } 
    } 
} 

maintenant quelque temps un élément ne soit pas remplacé. Donc, ma solution à cela appelle conteneur.Remplacer sur une autre méthode et faire un "verrou" qui fonctionne mais est-ce la bonne façon?

private class ModiflyString 
{ 
     public void Do(string x, string y) 
      { 
       lock (this) 
       { 
        fileInput.Replace(x, y); 
       } 
      } 
} 

Answer 1

Vous devez verrouiller l'objet StringBuilder lui-même (dans le remplacement des fonctions):

lock (container) 
{ 
    container.Replace("this", "With this"); 
} 

ou créer un objet de verrouillage séparé:

static object _stringLock = new object(); 

... 

lock(stringLock) 
{ 
    container.Replace("this", "With this"); 
} 

Answer 2

Votre verrouillage ne fonctionnera pas lorsque vous créez plus d'un objet ModifyString et je suppose que vous le faites.

Une version simple:

public void Do(string x, string y) 
    { 
     lock (fileInput) 
     { 
     fileInput.Replace(x, y); 
     } 
    } 

Il peut être préférable de créer un objet distinct pour faire le verrouillage, mais le montre au-dessus du principe mieux: toutes les discussions concurrentes doivent se verrouiller sur le même objet.

Une approche standard ressemblerait à ceci:

private static StringBuild container = new StringBuilder(); 
private static object syncLock = new object(); // simple object, 1-1 with container 

et vous pouvez (thread-) utiliser en toute sécurité:

lock(syncLock) 
    { 
     container.Replace(...); 
    } 

Answer 3

Cela fonctionnera correctement tant que les deux threads ont la même instance de la classe ModifyString. En d'autres termes, cela fonctionne parce que le verrou sur « ce » doit être un verrou sur la même instance:

class Blah 
{ 
    private static StringBuild container = new StringBuilder(); 

    private static ModifyString modifyString = new ModifyString(); 

    static void Main(...) 
    { 
    container.Append(Read From File(Kind of long)); 
    Thread thread1 = new Thread(Function1); 
     Thread thread2 = new Thread(Function2); 
    thread1.Start(); 
    thread2.Start(); 
    //Print out container 
    } 

    static void Function1 
    {  

     //Do calculation and stuff to get the Array for the foreach 
     foreach (.......Long loop........) 
     { 
      modifyString.Do("this", "With this") 
     } 
    } 
    //Same goes for function but replacing different things. 
    static void Function2 
    { 
     //Do calculation and stuff to get the Array for the foreach 
     foreach (.......Long loop........) 
     { 
      modifyString.Do("this", "With this") 
     } 
    } 
} 

Il PAS travail si vous avez fait le ci-dessous, parce que verrou (cela) ne fonctionnerait pas sens, ils sont deux cas distincts:

class Blah 
{ 
    private static StringBuild container = new StringBuilder(); 

    static void Main(...) 
    { 
    container.Append(Read From File(Kind of long)); 
    Thread thread1 = new Thread(Function1); 
     Thread thread2 = new Thread(Function2); 
    thread1.Start(); 
    thread2.Start(); 
    //Print out container 
    } 

    static void Function1 
    { 
     ModifyString modifyString = new ModifyString(); 
     //Do calculation and stuff to get the Array for the foreach 
     foreach (.......Long loop........) 
     { 
      modifyString.Do("this", "With this") 
     } 
    } 
    //Same goes for function but replacing different things. 
    static void Function2 
    { 
     ModifyString modifyString = new ModifyString(); 

     //Do calculation and stuff to get the Array for the foreach 
     foreach (.......Long loop........) 
     { 
      modifyString.Do("this", "With this") 
     } 
    } 
} 

Certaines personnes effectivement créer un objet « factice » pour effectuer la serrure au lieu d'utiliser « ce » (vous ne pouvez pas verrouiller sur la corde, car il est un type de valeur).