Programmation Java multi-thread pour fournir un support intégré. Un fil se réfère à un écoulement de commande unique d'une séquence de processus, un processus peut être compliquée par une pluralité de fils, chaque fil en parallèle pour effectuer des tâches différentes.

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

Un autre terme est défini ici et le filetage associé - procédés: un procédé comprenant l'allocation d'espace mémoire par le système d'exploitation, comprenant un ou plusieurs fils. Un thread séparé ne peut pas exister, il doit faire partie du processus. Un procédé a été exécuté, pour mettre fin jusqu'à ce que tous les fils de non-fonctionnement démon avoir fini.

Multithreading peut répondre aux programmeurs d'écrire des programmes efficaces pour obtenir une pleine utilisation de la CPU.

A. Un fil du cycle de vie

Un thread est un processus dynamique d'exécution, il a aussi un processus de la création à la mort.

Nouvel Etat : Après avoir établi un objet thread et le nouveau mot - clé classe Thread ou sous - classe, le fil est dans le nouvel état de l'objet. Il reste dans cet état jusqu'à début du programme () ce fil.

** état prêt: ** Lorsqu'un objet thread appeler la méthode start (), le fil dans l'état prêt. fil prêt dans la file d'attente prêt, en attendant de programmer le programmateur de fil machine virtuelle Java.

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

état de blocage : Si un thread est exécuté après le sommeil (sommeil), suspendent ( en attente) et d' autres méthodes, la perte des ressources occupées, le fil passe à l'état bloqué de la course. Dans le temps de sommeil est venu d'obtenir l' équipement ou les ressources peuvent pénétrer dans l'état prêt. Il peut être divisé en trois types:

En attente de blocage: threads d'exécution en cours d'exécution Procédé état d'attente (), le fil est bloqué en attente pour entrer dans l'état.
blocage synchrone: se synchroniser échec de verrouillage de la synchronisation des threads (car un autre verrou de synchronisation de fil est occupé).
Autre blocage: Problème de la demande d'E / S, le fil passe à l'état en bloquant le sommeil thread appelant () ou joindre (). Lorsque le sommeil délai d'attente (), Join () attente d'un fil ou de mettre fin à un délai d'attente ou le traitement d'E / S est terminée, le fil dans l'état prêt.

L'état de la mort : un fil pour compléter la tâche d'exécuter l'état ou une autre condition de terminaison se produit, le fil passe à la fin de l'Etat.

Thread.run () et Thread.start () la différence entre :

méthode start () pour démarrer un fil, une vraie mesure multi-fileté. Puis, sans attendre le code du corps de la méthode d'exécution est terminée, vous pouvez passer directement au code suivant, pour démarrer un thread en appelant la méthode start classe Thread (), alors ce fil est à l'état prêt et ne fonctionne pas. Ensuite, cette méthode appelle la course de classe Thread () pour terminer son opération d'exécution, où la méthode run () est appelée corps de fil, qui contient le contenu de ce fil à exécuter, mettre fin à la méthode Run pour exécuter ce fil de mettre fin. Ensuite, rééchelonnements CPU autres threads.
Appelez la méthode run () comme méthode régulière de façon. Pour effectuer une procédure ou une commande, attendre que le procédé de fonctionnement après la mise en œuvre de celui-ci, de procéder par le code suivant, ce programme, seul le fil conducteur est un fil, qui est seulement un chemin d'exécution de programme, de sorte qu'il est inutile de threads d'écriture.

II. La différence entre le sommeil et attente

Ces deux méthodes sont de différentes catégories: le sommeil de la classe Thread, classe d'objets de l'attente. le sommeil est une méthode statique du fil, qui a appelé qui vont se coucher, même si la méthode appelant b du sommeil dans un fil, en fait, toujours aller dormir, laissez b fils dormir du sommeil dans le code pour appeler les b.

Lock: le sommeil est la méthode la plus importante est pas libérer la serrure, la méthode d'attente de libération de verrouillage, de sorte que d'autres threads peuvent être utilisés ou une méthode d'un bloc de commande de synchronisation. ** sommeil ne pas vendre les ressources du système, attente est en attente d'entrer dans le pool de threads d'attendre et de laisser les ressources du système, d'autres threads peuvent occuper CPU. ** habituellement attendre n'augmenter la limite de temps, parce que vous avez un fil d'attente des ressources ne suffit pas, alors il est inutile d'attendre que les autres appels de fil notify / notifyAll se réveille toutes les threads en attente dans la piscine, entrera dans la file d'attente prêt d'attente système de distribution du système d'exploitation ressources. sommeil (millisecondes) peut être spécifié de temps il se réveille automatiquement, ne peut être appelé si moins d'interruption () force interrompue. Rôle Thread.sleep (0) est « le système d'exploitation déclenche immédiatement une compétition re CPU. »

Plage: attente, notification et notifyAll seule méthode de contrôle de synchronisation pour contrôler la synchronisation ou un bloc (la synchronisation) utilisé dans, mais peut être utilisé dormir partout:

   synchronized(x){ 
      x.notify() 
     //或者wait() 
   }
复制代码

Priorité III. Discussion

Chaque thread Java a une priorité, ce qui permet de déterminer le fil du système d'exploitation afin d'ordonnancement.

Java priorité de fil 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 au programme, et devrait allouer des ressources du processeur avant d'abaisser fil de priorité. Cependant, l'ordre ne garantit pas fil fil de priorité d'exécution, mais aussi très dépendant de la plate-forme.

IV. Création d'un fil

Java propose trois façons de créer des fils:

En mettant en œuvre l'interface Runnable;
Par héritage classe Thread lui-même;
Créer un fil à travers appelable et avenir.

En mettant en œuvre l'interface Runnable

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}
复制代码

Par héritage classe Thread lui-même

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 让线程睡眠一会
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}
复制代码

Créer un fil à travers appelable et avenir

Créer l'interface des méthodes appelable classe d'implémentation, et met en œuvre appel (), la méthode call () comme fil d'exécution, et les valeurs de retour.
Appelables créer une instance de la classe de mise en œuvre, en utilisant l'emballage appelable FutureTask objet de classe, quel objet encapsule FutureTask objet appelable de la méthode retourne l'appel () la valeur.
Utilisez FutureTask objet Thread comme un objet cible pour créer et démarrer un nouveau thread.
Appeler la méthode d'objet FutureTask get () pour obtenir la valeur de retour après la fin de l'exécution de sous-fil.

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的线程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子线程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}
复制代码

Comparaison des trois méthodes pour créer des fils

Lorsque vous utilisez créer plusieurs threads pour obtenir Runnable, des moyens d'interface appelables, outils de discussion de classe d'interface Runnable ou tout simplement l'interface externe, vous pouvez également hériter d'autres classes.
Lorsque vous créez une classe d'héritage multi-usage-thread fil, simple à préparer, si vous avez besoin d'accéder au thread courant, vous n'avez pas besoin d'utiliser la méthode Thread.currentThread (), l'utilisation directe ceci pour obtenir le thread courant.

Plusieurs concepts majeurs V. fil

Dans la programmation multi-thread, vous devez comprendre les concepts suivants:

discussion synchronisation
communication inter-thread
impasse de discussion
Enfilez contrôle: suspendre, arrêter et reprendre

VI. L'utilisation multithread

La clé pour une utilisation efficace de multithreading est de comprendre le programme est exécuté en même temps plutôt que exécutée en série. Par exemple: Il existe deux sous-programmes doivent être exécutés en même temps, cette fois, vous devez profiter de la programmation multi-thread.

Par l'utilisation de plusieurs threads, vous pouvez écrire un programme très efficace. Veuillez toutefois noter que si vous créez trop de threads, l'efficacité de l'exécution du programme est en fait réduite, plutôt que renforcée.

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

Java connaissance commune Résumé (⑬) - Discussion