Synchronisation de deux threads

Question

J'ai deux threads dans C# .. Maintenant j'ai besoin d'attendre qu'une instruction particulière soit exécutée avant de pouvoir continuer l'exécution dans l'autre thread qui est évidemment un cas de synchronisation. Y a-t-il du code qui peut faire cela comme dans l'utilisation d'une méthode intégrée?

Voici l'exemple de code:

public void StartAccept() 
    { 
      try 
      { 
       newSock.BeginAccept(new AsyncCallback(Accepted), newSock); 
      } 
      catch (ArgumentException) 
      { 
       MessageBox.Show("Error in arguments while using begin-accept", "Error", MessageBoxButtons.OK); 
      } 
      catch (ObjectDisposedException) 
      { 
       MessageBox.Show("socket closed while using begin-accept", "Error", MessageBoxButtons.OK); 
      } 
      catch (SocketException) 
      { 
       MessageBox.Show("Error accessing socket while using begin-accept", "Error", MessageBoxButtons.OK); 
      } 
      catch (InvalidOperationException) 
      { 
       MessageBox.Show("Invalid operation while using begin-accept", "Error", MessageBoxButtons.OK); 
      } 
      catch (Exception) 
      { 
       MessageBox.Show("Exception occurred while using begin-accept", "Error", MessageBoxButtons.OK); 
      } 

    } 

Ce reçoit des données de l'hôte désiré qui est sélectionné par le code:

private void listBox1_Click(object sender, EventArgs e) 
    { 



     String data = (String)this.listBox1.SelectedItem; 

     ip = Dns.GetHostAddresses(data); 

     clientIP = new IPEndPoint(ip[0], 5555); 

     newSock.Bind(clientIP); 
     newSock.Listen(100); 

    } 

Ainsi, afin de commencer à recevoir des données que je dois initialiser le socket à l'hôte distant particulier qui est fait quand je clique sur l'un des hôtes affichés dans la liste. Pour cela j'ai besoin de la synchronisation.

Answer 1

Java a quelque chose appelé Join. Je soupçonne qu'il y aura aussi une méthode prédéfinie en C#.

Answer 2

Jetez un oeil à AutoResetEvent et ManualResetEvent. Ce sont des signaux qui rendent la synchronisation entre les threads possible.

Le premier thread qui doit attendre que quelque chose soit fait fera myEvent. WaitOne(), qui bloque jusqu'à ce que l'autre thread appelle myEvent. Set(). Disons que nous avons deux threads, où l'un d'entre eux doit faire une sorte d'initialisation avant que l'autre thread puisse continuer. Vous partagez ensuite un AutoResetEvent entre les deux, appelons-le myEvent. Ne confondez pas ceci avec une ressource partagée où l'ordre d'accès n'a pas d'importance. Par exemple, si vous avez une liste partagée ou un dictionnaire partagé, vous devez l'envelopper dans un mutex afin de garantir qu'ils s'exécutent correctement.

// Mutex example 

object mySync = new object(); 
Dictionary<int, int> myDict = new Dictionary<int, int>(); 

void threadMainA() 
{ 
    lock(mySync) 
    { 
     mySync[foo] = bar; 
    } 
} 

void threadMainB() 
{ 
    lock(mySync) 
    { 
     mySync[bar] = foo; 
    } 
} 

Answer 3

Vous pouvez utiliser un événement AutoResetEvent.

Dans l'exemple suivant deux méthodes s'appelées par différents threads et DoSomethingA() sera exécutée et la finition avant DoSomethingB() commence:

AutoResetEvent resetEvent = new AutoResetEvent(false); 

void ThreadWorkerA() 
{ 
    // perform some work 
    DoSomethingA(); 

    // signal the other thread 
    resetEvent.Set(); 
} 

void ThreadWorkerB() 
{ 
    // wait for the signal 
    resetEvent.WaitOne(); 

    // perform the new work 
    DoSomethingB(); 
} 

Note: souvenez-vous de disposer de la AutoResetEvent :)