Discussion synchronisation

Question

J'ai 2 fils dans mon programme comme suit:

class SendThread implements Runnable { 
    public void run(){ 
      Thread.sleep(1000); 

      while (true){  
       if (CONNECTION_ESTABLISHED){ 
        // code here 
       } 
      } 
    } 
} 

class ReceiveThread implements Runnable { 
    public void run(){ 


      while (true){  
       // code here 
       CONNECTION_ESTABLISHED = true; 

      } 
    } 
} 

J'ai défini CONNECTION_ESTABLISHED comme static Boolean. Dans le deuxième fil, le BooleanCONNECTION_ESTABLISHED est défini sur true à un certain point. Si je n'utilise pas Thread.sleep(1000) dans le 1er thread, après CONNECTION_ESTABLISHED est défini sur true dans le 2ème thread, je ne pas entrer l'instruction if pertinente dans le 1er thread.

Existe-t-il une autre solution? Parce que mon 1er thread dépendra souvent des changements de variables dans le deuxième thread.

Answer 1

Ajoutez volatile à la méthode CONNECTION_ESTABLISHED et voir.

Answer 2

Vous êtes confronté au défi car vous modifiez la variable statique CONNECTION_ESTABLISHED de manière non synchronisée et vous n'utilisez pas le mécanisme d'attente de notification pour la communication de thread. Utiliser wait notify devrait vous aider. Créer un objet à utiliser pour attentiste notifier et utiliser le code ci-dessous

class SendThread implements Runnable { 
    public void run(){ 
      Thread.sleep(1000); 

      while (true){ 
       synchronized(object) { 
        object.wait(); 
        if (CONNECTION_ESTABLISHED){ 
         // code here 

        } 
       } 
      } 
    } 
} 

class ReceiveThread implements Runnable { 
    public void run(){ 


      while (true){ 
       synchronized(object) { 
        // code here 
        CONNECTION_ESTABLISHED = true; 
        object.notify(); 
        } 
      } 
    } 
} 

Je ne l'ai pas testé le code, je viens d'essayer de mettre le concept si apporter des modifications au besoin.

Answer 3

Dans cet exemple particulier, vous pouvez marquer le booléen CONNECTION_ESTABLISHED comme volatil et cela fonctionnera comme prévu, les autres threads verront la modification la prochaine fois qu'ils accèderont à la variable.

Cependant, je vous met en garde contre l'utilisation de volatiles pour n'importe quoi sauf les cas les plus simples (mise à jour de variable unique). Il ne fournit aucune atomicité, donc si vous avez besoin de faire plus qu'une seule affectation lors d'une mise à jour, il ne fournira pas les garanties nécessaires. Cela inclut les incréments/décréments qui sont en réalité 3 opérations, lire/modifier/écrire au niveau du modèle de mémoire, donc nécessite une synchronisation correcte.

Dans ce cas, vous devez utiliser un bloc synchronisé autour de la lecture et de l'écriture.

private final Object lock = new Object(); 

private int shared1; 
private int shared2; 

public void write(int var1, int var2) 
{ 
    sychronized (lock) 
    { 
    shared1 = var1; 
    shared2 = var2; 
    } 
} 

public int readSum() 
{ 
    sychronized (lock) 
    { 
    int total = shared1 + shared2; 
    return total; 
    } 
}