L'accesso alla stessa stringa (StringBuilder) utilizzando multi-thread

Question

Il mio problema è se uso multi-thread sulla stessa corda qualche tempo

la stringa non verrà sostituire. (Ho scritto questo sul blocchetto per appunti in modo sintassi può essere

sbagliato)

utilizzando System.Thread ... Altro 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")
    }
    }
}

Ora a volte qualche elemento non viene sostituisce. Quindi la mia soluzione a questo è chiamata container.Replace su un diverso

metodo e fare un "blocco", che il lavoro, ma è la strada giusta?

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

Answer 1

Si dovrebbe bloccare l'oggetto StringBuilder in sé (all'interno delle funzioni sostituire):

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

o creare un oggetto di blocco a parte:

static object _stringLock = new object();

...

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

Answer 2

Il blocco non funziona quando si crea più di 1 oggetto ModifyString e sto cercando di indovinare che fate.

Una semplice versione:

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

Può essere preferibile creare un oggetto separato per fare il blocco su, ma quanto sopra mostra il principio meglio:. Tutte le discussioni concorrenti devono bloccare sullo stesso oggetto

Un approccio standard sarà simile:

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

e quindi si può (filettatura) utilizzare in sicurezza:

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

Answer 3

Che funzionerà bene fino a quando entrambi i fili hanno la stessa istanza della classe ModifyString. In altre parole, questo sistema funziona perché la serratura su "questo" deve essere un blocco sulla stessa istanza:

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")
        }
    }
}

Sarà non il lavoro se avete fatto il seguito, a causa di blocco (questa) non funzionerebbe senso si tratta di due casi separati:

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")
        }
    }
}

Alcune persone effettivamente creare un oggetto "fittizio" per eseguire il blocco su invece di usare "questo" (non è possibile bloccare sulla stringa in quanto si tratta di un tipo di valore).