Exemple de partage de fonction de synchronisation en Java

Cet article présente principalement des informations pertinentes sur l'explication détaillée de la fonction de synchronisation en Java. J'espère que cet article pourra aider tout le monde à comprendre comment utiliser la fonction de synchronisation. Les amis dans le besoin peuvent se référer à

. Explication détaillée d'exemples de fonction de synchronisation en Java

Si une fonction membre d'une classe en Java est modifiée avec synchronisé, elle correspond au même objet. Plusieurs threads doivent attendre d'appeler la fonction de synchronisation de. cet objet. Le thread suivant ne peut l'appeler qu'après que le thread précédent l'a appelé.

Donc, si une classe a deux fonctions membres qui sont modifiées par synchronisation comme indiqué dans le code, pour le même objet, l'une peut-elle appeler funcA et l'autre appeler funcB lorsque deux threads sont en cours d'exécution ?

Mysyn est une telle classe. Si j'ai deux threads, l'un exécute d'abord funcA puis funcB dans la méthode run, et l'autre thread exécute d'abord funcB puis funcA dans la méthode run. Est-il possible que lors de la sortie du démarrage A..., la sortie directe du démarrage B... ?

public class MySyn { 
  public synchronized void funcA(String str){ 
    System.out.println(str+":"); 
    System.out.println("start A..."); 
    try { 
      Thread.sleep(5000); 
    } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } 
    System.out.println("...A end"); 
  } 
   
  public synchronized void funcB(String str){ 
    System.out.println(str+":"); 
    System.out.println("start B..."); 
    try { 
      Thread.sleep(5000); 
    } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } 
    System.out.println("...B end"); 
  } 
}

Le code de test est le suivant :

Ce fil exécute funcA en premier

public class Mythread implements Runnable { 
 
  private MySyn mysyn; 
  private String id; 
  public Mythread(MySyn syn, String id){ 
    this.mysyn = syn; 
    this.id = id; 
  } 
  @Override 
  public void run() { 
     
    this.mysyn.funcA(id); 
    try { 
      Thread.sleep(1000); 
    } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
    } 
    this.mysyn.funcB(id); 
  } 
   
  public static void main(String arg[]){ 
    MySyn syn=new MySyn(); 
    Thread t1 = new Thread(new Mythread(syn, "t1")); 
    Thread t2 = new Thread(new YourThread(syn, "t2")); 
     
     
    t1.start(); 
    t2.start(); 
  } 
}

Ce fil exécute funcB en premier

public class YourThread implements Runnable { 
 
  private MySyn mysyn; 
  private String id; 
  public YourThread(MySyn syn, String id){ 
    this.mysyn = syn; 
    this.id=id; 
  } 
  @Override 
  public void run() { 
    this.mysyn.funcB(id); 
    this.mysyn.funcA(id); 
     
 
  } 
 
}

Les résultats de sortie sont principalement :

t1: 
start A... 
...A end 
t2: 
start B... 
...B end 
t2: 
start A... 
...A end 
t1: 
start B... 
...B end

Si vous annulez la mise en veille entre les deux appels de fonction dans la méthode run de Mythread, le résultat peut être :

t1: 
start A... 
...A end 
t1: 
start B... 
...B end 
t2: 
start B... 
...B end 
t2: 
start A... 
...A end

Les résultats individuels peuvent différer en raison de la planification des threads, mais ils ne le feront jamais. Il y aura : start A... suivi de start B directement...

Si funcB n'est pas une fonction synchrone, quel sera le résultat du code ci-dessus ?

Le code est légèrement modifié pour supprimer le mot-clé synchronisé de funcB. Le résultat courant est :

t2: 
t1: 
start A... 
start B... 
...A end 
t1: 
start B... 
...B end 
t2: 
start A... 
...B end 
...A end

Évidemment, le résultat du démarrage A... est directement sorti après le démarrage B....

De même, si la classe Mysyn a une variable membre publique, les multi-threads peuvent également modifier la variable membre par un autre thread pendant que la fonction de synchronisation est appelée.

L'expérience ci-dessus illustre : les fonctions membres synchronisées ne peuvent avoir un effet exclusif que sur d'autres fonctions synchronisées (y compris elles-mêmes) dans l'appel de fonction synchronisée du même objet. C'est-à-dire, lors de l'exécution multithread, du même objet. est actuellement Une seule fonction synchronisée peut être exécutée, mais cela n'exclut pas que d'autres fonctions non synchronisées s'exécutent ou accèdent aux membres.

Supposons maintenant qu'une classe dispose de deux méthodes de synchronisation statique, qu'en est-il de la situation ?

Je ne répéterai pas l'implémentation spécifique, car les résultats sont similaires :

En multi-threading, la même classe ne peut actuellement avoir qu'une seule fonction de synchronisation de classe (fonction de synchronisation statique) en cours d'exécution. Mais cela n'exclut pas l'exécution d'autres fonctions statiques non synchronisées ni l'accès aux membres statiques

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!