Pressé, depuis le lieu de travail pour faire un programme multi-thread avec Java Je vais résumer ce que j'ai appris à la hâte pour répondre à des demandes déraisonnables.
Si le chemin d'accès au démarrage du sous-thread est petit et que vous ne souhaitez pas conserver le sous-thread en tant qu'instance, combinez des expressions lambda
ThreadStartTemplate.java
new Thread( () -> {Méthode ou processus que vous souhaitez exécuter dans un sous-thread} ).start()
Cela semble bon. C'est pratique.
J'ai reporté l'installation d'Eclipse par moi-même, et pour le moment, j'ai utilisé paiza.io pour vérifier la grammaire.
Il semble que les threads peuvent être implémentés avec les deux modèles suivants.
Il semble que Java possède une interface Runnable, et en surchargeant run (), il semble que le traitement exécuté au moment du thread puisse être implémenté. L'utilisation est la suivante.
L'exemple de code écrit selon cette rue est RunnableSample.java.
RunnableSample.java
import java.util.*;
public class Main {
private static class RunnableSample implements Runnable{
private String thread_no;
RunnableSample(String str){
this.thread_no = str;
}
public void run(){
System.out.println("RunnableThread Starting No."+thread_no);
}
}
public static void main(String[] args) throws Exception {
String str1 = "1";
String str2 = "2";
RunnableSample runner1 = new RunnableSample(str1); // 1.
RunnableSample runner2 = new RunnableSample(str2); // 1.
Thread thread1 = new Thread(runner1); // 2.
Thread thread2 = new Thread(runner2); // 2.
thread1.start(); // 3.
thread2.start(); // 3.
Thread.sleep(200);
System.out.println("MainThread End");
}
}
Résultat d'exécution
RunnableThread Starting No.1
RunnableThread Starting No.2
MainThread End
La classe RunnableSample est définie comme une classe locale de la classe Main. Créez un objet de la classe RunnableSample à partir du thread principal et exécutez-le en tant que deux sous-threads.
RunnableThread Starting No.1 RunnableThread Starting No.2 Peut être émis dans l'ordre inverse. L'extrémité du fil principal sera généralement sortie en dernier car elle a une veille de 200 ms entre les deux.
Ensuite, j'écrirai sur la façon d'hériter de la classe Thread et d'implémenter le traitement des sous-threads. L'utilisation est la suivante. Le code est ThreadSample.java.
ThreadSample.java
import java.util.*;
public class Main {
private static class ThreadSample extends Thread{
private String thread_no;
ThreadSample(String str){
this.thread_no = str;
}
public void run(){
System.out.println("RunnableThread Starting No."+thread_no);
}
}
public static void main(String[] args) throws Exception {
String str1 = "1";
String str2 = "2";
ThreadSample thread1 = new ThreadSample(str1); // 1.
ThreadSample thread2 = new ThreadSample(str2); // 1.
thread1.start(); // 2.
thread2.start(); // 2.
Thread.sleep(200);
System.out.println("MainThread End");
}
}
Résultat d'exécution
RunnableThread Starting No.2
RunnableThread Starting No.1
MainThread End
Le résultat de l'exécution sera le même (cette fois, l'ordre de sortie de Thread1 et Thread2 a été inversé).
En gros, l'utilisation de l'interface Runnable présente de nombreux avantages.
--Java n'autorise pas l'héritage multiple, donc si vous héritez de la classe Thread, les autres classes ne pourront pas en hériter. Toute classe qui implémente l'interface Runnable peut hériter d'autres classes.
Ce serait parfait si je pouvais écrire proprement même avec l'interface Runnable. Je vais essayer.
Essayez de simplifier le code avec des expressions lambda en vous reportant à Présentation des expressions lambda Java 8.
LambdaThreadSample.java
import java.util.*;
public class Main {
static private void subthread_run(String thread_no){
System.out.println("RunnableThread Starting No."+thread_no);
}
public static void main(String[] args) throws Exception {
String str1 = "1";
String str2 = "2";
new Thread( () -> {subthread_run(str1);} ).start();
new Thread( () -> {subthread_run(str2);} ).start();
Thread.sleep(200);
System.out.println("MainThread End");
}
}
Résultat d'exécution
RunnableThread Starting No.2
RunnableThread Starting No.1
MainThread End
Pour la méthode de description détaillée, reportez-vous à Understanding Java 8 Lambda Expressions, mais ~~ difficile à expliquer ~~ La classe RunnableSample est une classe anonyme avec une méthode subthread_run, et l'objet de classe Thread est nouveau et démarré. En utilisant la formule lambda, le programme est devenu beaucoup plus propre et plus lisible. C'est un bon moyen d'écrire si vous n'avez pas besoin de gérer Thread en tant qu'instance. Ensuite, je voudrais résumer Synchronisé.
150 questions pour former des compétences en programmation pour combattre dans le monde Chapitre 16: Threads et verrous
Recommended Posts