Java programmation multi-thread

Java programmation multi-thread pour fournir un soutien intégré. Un programme multithread contient deux ou plusieurs parties peuvent exécuter simultanément. Chaque partie du programme est appelé un fil, et chaque fil définit un chemin séparé de l'exécution.

Multithreading est une forme particulière de multi-tâches, multi-threading, mais utiliser une surcharge de ressources plus petit.

Un autre terme est défini ici, et en relation-fil - processus: un processus, y compris le système d'exploitation alloue de l'espace mémoire qui contient un ou plusieurs fils. Un thread séparé ne peut pas exister, il doit faire partie du processus. Il existe un processus en cours d'exécution à la fin de tous les non-attente jusqu'à ce que l'extrémité du fil à exécuter.

Multithreading peut répondre aux programmeurs d'écrire programme efficace pour atteindre des fins complètes d'utilisation de la CPU.

Le cycle de vie d'un fil

Enfilez à travers toutes les étapes de son cycle de vie. La figure suivante montre le cycle de vie complet d'un fil.

• Nouveau Statut:

  Après avoir utilisé le nouveau mot - clé et la classe Thread ou sous - classe pour créer un objet thread, l'objet thread est dans un nouvel état. Il reste dans cet état jusqu'à ce que le début du programme () ce fil.

• Prêt:

  Quand un objet thread pour appeler la méthode start (), le fil dans l'état prêt. Prêt fil dans la file d'attente prête à attendre pour le fil de JVM programmateur horaire.

• Etat de fonctionnement:

  Si le thread obtient état prêt des ressources du processeur, vous pouvez effectuer run (), le fil sera en cours d' exécution à ce moment. Fil conducteur le plus complexe, il peut devenir état bloqué, état prêt, et l'état de la mort.

• état bloqué:

  Si un thread est exécuté après le sommeil (sommeil), suspendre (bloquer) et d'autres méthodes, la perte de ressources occupées, le fil entre dans l'état bloqué de courir. Après le temps de sommeil est venu d'obtenir de l'équipement ou de ressources pour ré-entrer dans l'état prêt.

• Mort Statut:

  Quand un thread état de la tâche ou d'une autre condition de terminaison en cours d'exécution se produit, le fil est commuté à l'état final.

La priorité d'un fil

Chaque thread Java a une priorité, ce qui aide à déterminer le système d'exploitation ordonnancement des threads commande.

La priorité de thread Java est un nombre entier qui varie de 1 (Thread.MIN_PRIORITY) - 10 (Thread.MAX_PRIORITY).

Par défaut, chaque thread est attribué un NORM_PRIORITY prioritaire (5).

Discussion avec une priorité plus élevée est plus important pour le programme, et devrait allouer des ressources de processeur avant les discussions de faible priorité. Cependant, l'ordre ne garantit pas du fil fil de priorité d'exécution, et est très dépendante de l'internet.

Créer un fil

Java fournit deux méthodes pour créer un fil:

• Runable en mettant en œuvre l'interface;
• Grâce à l'héritage classe Thread lui-même.

Pour créer un fil en mettant en œuvre l'interface Runnable

Créer un fil, le plus simple est de créer une classe qui implémente l'interface Runnable.

Pour atteindre Runnable, une classe doit seulement effectuer une course d'appel de méthode (), la déclaration suivante:

public void run()

Vous pouvez remplacer cette méthode, il est important de comprendre le run () peuvent appeler d'autres méthodes, l'utilisation d'autres classes, et déclarer une variable, tout comme le thread principal.

Après avoir créé une classe implémente l'interface Runnable, vous pouvez instancier un objet dans la classe un fil.

Discussion définit plusieurs constructeurs, suivent ce que nous utilisons souvent:

Thread(Runnable threadOb,String threadName);

Ici, threadOb est une instance d'une classe qui implémente l'interface Runnable, et threadName spécifier le nouveau nom du fil.

Après le nouveau thread est créé, vous appelez sa méthode start () elle sera exécutée.

void start();

Exemples

Voici un exemple de celui-ci pour créer un fil et commencer à exécuter:

// 创建一个新的线程
class NewThread implements Runnable {
   Thread t;
   NewThread() {
      // 创建第二个新线程
      t = new Thread(this, "Demo Thread");
      System.out.println("Child thread: " + t);
      t.start(); // 开始线程
   }
  
   // 第二个线程入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
            // 暂停线程
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
     }
     System.out.println("Exiting child thread.");
   }
}
 
public class ThreadDemo {
   public static void main(String args[]) {
      new NewThread(); // 创建一个新线程
      try {
         for(int i = 5; i > 0; i--) {
           System.out.println("Main Thread: " + i);
           Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Compiler le programme ci-dessus fonctionne comme suit:

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Pour créer un fil par fil héritage

La deuxième façon de créer un thread est de créer une nouvelle classe qui hérite de la classe Thread, puis créer une instance d'une classe.

Héritant classe doit remplacer la méthode run (), qui est le point pour le nouveau fil d'entrée. Il doit également appeler la méthode start () pour exécuter.

Exemples

// 通过继承 Thread 创建线程
class NewThread extends Thread {
   NewThread() {
      // 创建第二个新线程
      super("Demo Thread");
      System.out.println("Child thread: " + this);
      start(); // 开始线程
   }
 
   // 第二个线程入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
                            // 让线程休眠一会
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
      }
      System.out.println("Exiting child thread.");
   }
}
 
public class ExtendThread {
   public static void main(String args[]) {
      new NewThread(); // 创建一个新线程
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Main Thread: " + i);
            Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Compiler le programme ci-dessus fonctionne comme suit:

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Méthodes de la discussion

Le tableau suivant présente la classe Thread quelques façons importantes:

Teste si ce fil est active. La méthode ci-dessus est appelé objet Thread. La méthode suivante est une méthode statique de la classe Thread.

Exemples

Le programme suivant illustre quelques-unes des façons ThreadClassDemo classe Thread:

// 文件名 : DisplayMessage.java
// 通过实现 Runnable 接口创建线程
public class DisplayMessage implements Runnable
{
   private String message;
   public DisplayMessage(String message)
   {
      this.message = message;
   }
   public void run()
   {
      while(true)
      {
         System.out.println(message);
      }
   }
}

// 文件名 : GuessANumber.java
// 通过继承 Thread 类创建线程

public class GuessANumber extends Thread
{
   private int number;
   public GuessANumber(int number)
   {
      this.number = number;
   }
   public void run()
   {
      int counter = 0;
      int guess = 0;
      do
      {
          guess = (int) (Math.random() * 100 + 1);
          System.out.println(this.getName()
                       + " guesses " + guess);
          counter++;
      }while(guess != number);
      System.out.println("** Correct! " + this.getName()
                       + " in " + counter + " guesses.**");
   }
}

// 文件名 : ThreadClassDemo.java
public class ThreadClassDemo
{
   public static void main(String [] args)
   {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
     
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();
 
      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try
      {
         thread3.join();
      }catch(InterruptedException e)
      {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
     
           thread4.start();
      System.out.println("main() is ending...");
   }
}

Les résultats sont les suivants, les résultats de chaque série ne sont pas les mêmes.

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Thread-2 guesses 27
Hello
** Correct! Thread-2 in 102 guesses.**
Hello
Starting thread4...
Hello
Hello
..........remaining result produced.

Enfilez plusieurs concepts majeurs:

Lorsque multithread programmation, vous devez comprendre les concepts suivants:

• Synchronisation Thread
• La communication entre les threads
• blocage de filetage
• Commande de fil: Suspend, arrêter et reprendre

Utilisez plusieurs threads

La clé de l'utilisation efficace des programmes multi-thread sont l'exécution simultanée est entendu plutôt que l'exécution en série. Par exemple: Le programme comporte deux sous-systèmes doivent exécuter simultanément, cette fois vous avez besoin pour profiter de la programmation multi-thread.

Grâce à l'utilisation de plusieurs threads, vous pouvez écrire un programme très efficace. Toutefois, s'il vous plaît noter que si vous créez trop de threads, l'efficacité de l'exécution du programme est effectivement réduite, plutôt que renforcée.

Rappelez-vous, l'interrupteur de tête de contexte est également très important, si vous créez trop de threads, le temps CPU passé dans le contexte du temps d'exécution du programme de commutation sera plus!