Les threads sont un concept très important dans la programmation Java. Cet article l'expliquera en détail sous forme d'exemples. L’analyse spécifique est la suivante :
Tout d’abord, à quoi sert le verrouillage des threads ? Par exemple : Par exemple, si vous avez actuellement 30 000 yuans à la banque et que vous vous rendez à la banque pour retirer l'argent, après avoir entré le mot de passe, vous avez déjà saisi le montant du retrait. Par exemple, si vous avez entré 20 000, il est indiqué. Cela signifie que la banque obtiendra l'argent pour vous. À ce moment-là, votre femme est également allée à la banque pour retirer l'argent, et vous. Ma femme retire également 20 000, car votre compte est encore à 30 000 à ce moment-là, donc la banque effectue la même opération du côté de votre femme, de cette façon, une fois que vous avez terminé vos opérations respectives, la banque devrait toujours avoir 30 000 enregistrés sur votre compte. . Une caution de 10 000 yuans, n’est-ce pas génial ? Pour résoudre ce problème, les connaissances sur le verrouillage des threads sont utilisées. Apprenons-le ensemble.
1. Un exemple de synchronisation de threads non gérée :
public class TextSync implémente Runnable{ /**Synchronisation de thread non gérée* @param args */ Time time = new Time(); public static void main(String[] args) { TextSync text = new TextSync(); (texte); Thread t2 = new Thread(text); t1.setName("t2.setName("t2"); t2.start(); } @Override public void run() { time.add(Thread.currentThread().getName()); class Time { private static int num = 0; try { num++; //Lorsque le premier thread s'exécute à ce stade, num devient 1 et le premier thread fait une pause pendant une seconde. //Lorsque le deuxième thread s'exécute à ce stade, num Il devient 2, et le deuxième fil s'arrête pendant une seconde. //Le numéro du premier thread devient également 2 à ce moment, donc le résultat final est 2 ; Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace( } System.out.println (name+); " est le "+num+"ième thread d'exécution." }}Résultat de sortie :
t2 est le deuxième thread d'exécution. t1 est le deuxième thread d'exécution.
2. Synchronisation des fils
public class TextSynctwo implémente Runnable{ /**Synchronisation des threads* @param args */ Time1 time = new Time1(); public static void main(String[] args) { TextSynctwo text = new TextSynctwo(); texte); Sujet t2 = nouveau Sujet(texte); t1.setName("t1"); t1.start(); t2.start(); } @Override public void run() { time.add(Thread.currentThread().getName() }}class Time1 { private static int num = 0; synchronisé verrouille le thread actuel, qui peut être déclaré lorsque la méthode est définie, ou définie dans la méthode. public synchronisé void add(String name){ //synchronized (this) {//Verrouillez le thread actuel pour l'empêcher d'être exécuté par d'autres threads try { num++; Thread.sleep(1000); catch (InterruptedException e) { e . printStackTrace(); } System.out.println(name+"est le "+num+"ième thread d'exécution.");Résultat de sortie :
t1 est le premier thread d'exécution. t2 est le deuxième thread d'exécution.
3. Impasse
classe publique TestDeadLock implémente Runnable{ /**Deadlock* @param args */ private int flag = 0; static Object o1 = new Object statique o2 = new Object public static void main(String[] args ) { TestDeadLock td1 = nouveau TestDeadLock(); TestDeadLock td2 = nouveau TestDeadLock(); = 1; td2.flag = 2; Fil t1 = nouveau Fil (td1); Fil t2 = nouveau Fil (td2); t1.setName("t2.setName("t1.start()); ; t2.start(); } @Override public void run() { System.out.println(Thread.currentThread().getName()); if(flag == 1){synchronisé(o1){ try { Thread.sleep(5000); catch (InterruptedException e) { e.printStackTrace( ); } synchronisé(o2){ System.out.println("1"); } } } if(flag == 2){ synchronisé(o2){ try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace( } synchronisé(o1){ System.out.println("2");4. Verrouiller
public class TT implémente Runnable{ /**Lock* @param args */ int b = 100; public static void main(String[] args) { TT tt = new TT(); .start(); try { tt.m2(); } catch (Exception e) { e.printStackTrace( } System.out.println(tt.b); } @Override public void run() { try { m1(); } catch (Exception e) { e.printStackTrace( } } private synchronisé void m1() lance une exception{ b = 1000; Thread.sleep(5000); System.out.println("b="+b); } privé synchronisé void m2() lance Exception{ Thread.sleep(2500); b = 2500 } }Le résultat est maintenant :
1000b=1000
On peut voir que m2 est exécuté en premier et que m1 ne peut pas être exécuté tant que m2 n'est pas terminé.
J'espère que cet article sera utile à la conception de la programmation Java de chacun.