Implémentation Java multi-thread

　　Les threads en Java sont souvent mentionnés, mais le travail de développement réel est rarement utilisé (au moins j'utilise moins). Ce qui suit présente plusieurs méthodes d'implémentation de threads communs

　　1. Héritez de la classe Thread et réécrivez la méthode run

　　　Nous implémentons le thread en intégrant la classe Thread et en réécrivant la méthode run, puis démarrons le thread via la méthode start

　　

 classe publique MyThread étend Thread { 

    @Override 
    public  void run () { 
        System.out.println ( "=================" + new Date ()); 
    } 

    public  static  void main (String [] args) {
         for ( int i = 0; i <10; i ++ ) { 
            MyThread myThread = new MyThread (); 
            myThread.start (); 
        } 
    } 
}

Exécutez la méthode principale pour tester l'effet:

 

　　2. En implémentant l'interface exécutable

　　Thread en tant que classe de threads en Java, il a un constructeur Runable comme paramètre de construction, nous pouvons implémenter davantage le thread en implémentant l'interface Runable. La même chose consiste à démarrer le thread jusqu'au début.

/ ** 
 * 通过 实现 Runable 接口
 * / 
public  class MyRunableImpl implémente Runnable { 

    private String name; 

    public MyRunableImpl (String name) {
         this .name = name; 
    } 

    @Override 
    public  void run () { 
        System.out.println (name + "================" + new Date ()); 
    } 

    public  static  void main (String [] args) {
         for ( int i = 0; i <10; i ++ ) { 
            MyRunableImpl myRunable = newMyRunableImpl ("myRunable" + i); 
            Thread t = nouveau Thread (myRunable); 
            t.start (); 
        } 
    } 
}

Exécutez la méthode principale pour tester l'effet:

 

 　　3. Passez à travers FutureTask

　　Cette méthode est similaire à la seconde, ou la méthode de construction Thread (Runnable) est utilisée. La différence est qu'au lieu d'implémenter Runable vous-même, vous utilisez FutureTask. FutureTask implémentée

L'interface RunnableFuture et l'interface RunnableFuture intègre l'interface Runable, nous pouvons donc également utiliser FutureTask comme paramètre de construction pour créer un thread. FutureTask prend en charge deux méthodes de construction paramétrées, ici nous utilisons Future (Callable). Tout d'abord, nous devons créer une classe qui doit implémenter l'interface Callable et la méthode d'appel.

la  classe publique MyCallable implémente Callable { 

    private String name; 

    public MyCallable (String name) {
         this .name = name; 
    } 

    @Override 
    public Object call () lève une exception { 
        System.out.println (name + "===============" + new Date ());
        nom de retour ; 
    } 
}

Classe de test

 classe publique FutureTaskTest { 

    public  static  void main (String [] args) lève ExecutionException, InterruptedException {
         for ( int i = 0; i <10; i ++ ) { 
            MyCallable myCallable = new MyCallable ("myCallable" + i); 
            FutureTask futureTask = new FutureTask (myCallable); 
            Thread t = new Thread (futureTask); 
            t.start (); 
            Object o = futureTask.get (); 
            System.out.println ("valeur de retour ============" + o); 
        } 
    } 
}

Exécutez la méthode principale pour tester l'effet:

 

 La méthode d'appel de l'interface Callable est appelée au démarrage du thread. Nous pouvons obtenir la valeur de retour de call () via la méthode FutureTask.get (). Notez que la méthode get bloquera le thread.

　　4. Utilisez des exécuteurs pour créer un pool de threads

　　Executors est une classe en java juc, nous pouvons l'utiliser pour créer un pool de threads et l'utiliser pour implémenter des threads. Cette méthode nécessite également une classe d'implémentation Callable, ici nous utilisons toujours la classe dans la troisième méthode.

 classe publique ExecutorsTest { 

    public  static  void main (String [] args) { 
        ExecutorService executorService = Executors.newFixedThreadPool (10 ); 
        List <Future <? >> list = new ArrayList <> ();
        for ( int i = 0; i <10; i ++ ) { 
            MyCallable myCallable = new MyCallable ("myCallable" + i); Soumission 
        
            future = executorService.submit (myCallable); 
            list.add (soumettre); 
        } pour (Future future: list) {
            try { 
                Object o = future.get (); 
                System.out.println ( "valeur de retour =============" + o); 
            } catch (InterruptedException e) { 
                e.printStackTrace (); 
            } catch (ExecutionException e) { 
                e.printStackTrace (); 
            } 
        } 
        executorService.shutdown (); 
    } 
}

Nous créons un pool de threads via Executors et ExecutorService.submit (Callable) démarre le thread. La méthode submit renvoie un objet Future et la valeur de retour de la méthode call de la classe d'implémentation Callable peut être obtenue via sa méthode get (). Après avoir effectué les opérations ci-dessus, vous devez appeler la méthode ExecutorService.shutdown, sinon le thread principal sera toujours en cours d'exécution.

Exécutez la méthode principale pour tester l'effet:

 

 Ce qui précède sont les moyens courants de créer plusieurs threads. Si ce n'est pas correct, veuillez laisser un commentaire pour tout le monde.