1. Priorité des fils
Exemples d'utilisation de la priorité du fil:
package cn.galc.test; public class TestThread6 {public static void main (String args []) {mythread4 t4 = new myThread4 (); MyThread5 t5 = new MyThread5 (); Thread t1 = nouveau thread (t4); Thread t2 = nouveau thread (t5); t1.setPriority (thread.norm_priority + 3); // Utilisez la méthode setPriority () pour définir la priorité des threads, et ici la priorité des threads T1 est définie / * * augmenter la priorité du thread T1 par le niveau 3 sur la base de la priorité normale (NORM_PRIORITY) * En ce sens, la valeur de la normale est beaucoup plus que celle de T2 * t1.start (); t2.start (); System.out.println ("La priorité du thread T1 est:" + t1.getPriority ()); // Utilisez la méthode getPriority () pour obtenir la priorité du thread et imprimer la priorité de T1 à 8}} class MyThread4 implémente Runnable {public void run () {for (int i = 0; i <= 1000; i ++) {System.out.println ("t1:" + i); }}} class MyThread5 implémente Runnable {public void run () {for (int i = 0; i <= 1000; i ++) {System.out.println ("================= T2:" + i); }}} Dès que la méthode run () se termine, le thread se termine.2. Synchronisation du thread
Exemples d'utilisation des mots clés synchronisés:
Le package cn.galc.Test; classe publique TestSync implémente Runnable {Timer Timer = new Timer (); public static void main (String args []) {testSync test = new TestSync (); Thread t1 = nouveau thread (test); Thread t2 = nouveau thread (test); t1.setName ("t1"); // définit le nom du thread t1 t2.setName ("t2"); // définit le nom du thread t2 t1.start (); t2.start (); } public void run () {timer.add (thread.currentThread (). getName ()); }} classe Timer {private static int num = 0; public / * synchronisé * / void add (nom de chaîne) {// Lors de l'ajout de synchronisé lors de la déclaration d'une méthode, cela signifie que l'objet actuel est verrouillé lors de l'exécution de cette méthode synchronisée (ceci) {/ * * Utiliser sychronisé (ceci) pour verrouiller l'objet actuel, de sorte qu'il n'y aura pas de problème de deux threads différents accédant à la même ressource objet au même moment. Ce n'est que lorsqu'un thread accède à ce que ce soit le prochain tour du thread pour accéder * / num ++; essayez {thread.sleep (1); } catch (InterruptedException e) {e.printStackTrace (); } System.out.println (nom + ": vous êtes les threads" + num + "à l'aide de la minuterie"); }}} Problème de blocage du thread:
package cn.galc.test; / * Cette applet simule le problème de l'impasse du thread * / classe publique TestDeadlock implémente Runnable {public int flag = 1; objet statique o1 = nouveau objet (), o2 = nouveau objet (); public void run () {System.out.println (thread.currentThread (). getName () + "Flag =" + Flag); / * * Après avoir exécuté le programme, j'ai constaté que le programme l'a exécuté et a imprimé l'indicateur, et je n'exécuterai plus jamais l'instruction if ultérieure * Le programme est mort ici, ni exécutant ni sortant * / / * Ceci est l'indicateur de thread = 1 * / if (Flag == 1) {synchronisé (o1) {/ * Utilisez le mot de clé synchronisé pour verrouiller l'objet 01 * / try {thread.Sleep (500); } catch (InterruptedException e) {e.printStackTrace (); } synchronisé (O2) {/ * * L'objet O1 a été verrouillé avant, tant qu'il peut verrouiller O2, vous pouvez exécuter le fonctionnement de l'impression 1 * Cependant, l'objet O2 ne peut pas être verrouillé ici, car l'objet O1 a été verrouillé dans un autre drapeau de thread = 0 * Bien que le thread qui verrouille l'objet O2 dorme chaque 500 millisecondes; }}}} / * * Les deux instructions si les instructions ne seront pas exécutées car elles ont causé le problème du thread impasse * Flag = 1 Ce thread attend Flag = 0 Ce thread déverrouille le verrouillage de l'objet O2, * et Flag = 0 Ce thread n'attend également pas de drap Flag = 0 * / if (Flag == 0) {synchronisé (o2) {/ * Nous utilisons ici Synchronisé pour verrouiller l'objet O2 First * / Try {Thread.Sleep (500); } catch (InterruptedException e) {e.printStackTrace (); } synchronisé (o1) {/ * * L'objet O2 a été verrouillé avant. Tant qu'il peut verrouiller l'O1, le fonctionnement de l'impression 0 peut être effectué. Cependant, l'objet O1 ne peut pas être verrouillé ici, car l'objet O1 a été verrouillé dans un autre thread de drapeau = 1. Bien que le fil qui verrouille l'objet O1 dorme tous les 500 millisecondes, il verrouille toujours O1 lors du sommeil * / System.out.println ("0"); }}}} public static void main (String args []) {testdeadlock td1 = new TestDeadlock (); TestDeadlock TD2 = new TestDeadlock (); td1.flag = 1; td2.flag = 0; Thread t1 = nouveau thread (td1); Thread t2 = nouveau thread (td2); t1.setName ("Thread TD1"); t2.SetName ("Thread TD2"); t1.start (); t2.start (); }}Il est préférable de résoudre le problème du délai de thread uniquement un seul objet, pas deux objets en même temps.
Questions des producteurs et des consommateurs:
Package cn.galc.test; / * Exemple Nom: Producteur - Problème de consomment * Nom de fichier source: ProduCerConsumer.Java * Points clés: * 1. Incohérence des données partagées / protection des ressources critiques * 2. Concept de verrouillage d'objet Java * 3. Synchronized Motway new SyncStack (); Runnable p = nouveau producteur (pile); Runnable c = nouveau consommateur (pile); Thread p1 = nouveau thread (p); Thread c1 = nouveau thread (c); p1.start (); c1.start (); }} classe syncstack {// implémentation de piles qui prennent en charge les opérations de synchronisation multithread private int index = 0; char [] data = nouveau char [6]; public synchronisé void push (char c) {if (index == data.length) {try {this.wait (); } catch (InterruptedException e) {}} this.notify (); données [index] = c; index ++; } public synchronisé char pop () {if (index == 0) {try {this.wait (); } catch (InterruptedException e) {}} this.notify (); indice--; return data [index]; }} Class Producer implémente Runnable {SyncStack Stack; Producteur public (SyncStack S) {Stack = S; } public void run () {for (int i = 0; i <20; i ++) {char c = (char) (math.random () * 26 + 'a'); stack.push (c); System.out.println ("produit:" + c); essayez {thread.sleep ((int) (math.random () * 1000)); } catch (InterruptedException e) {}}}} Class Consumer implémente Runnable {SyncStack Stack; Consumer public (SyncStack S) {Stack = S; } public void run () {for (int i = 0; i <20; i ++) {char c = stack.pop (); System.out.println ("Consommation:" + C); essayez {thread.sleep ((int) (math.random () * 1000)); } catch (InterruptedException e) {}}}}Ce qui précède est l'introduction complète aux fils Java. Vous pouvez combiner le premier article "Java doit apprendre et apprendre les fils (1)" pour apprendre, en espérant que cela peut vous aider.