Mode thread-per-message (ce travail vous est laissé)
Lorsque vous êtes très occupé, il y a un courrier en bas de l'entreprise, alors vous contestez votre collègue pour vous aider à obtenir votre messagerie afin que vous puissiez continuer à faire votre travail
En mode Thread-per-Message, l'extrémité du délégué du message et l'extrémité d'exécution sont des threads différents. La fin du délégué du message indiquera le thread d'exécution d'exécution, et ce travail vous sera remis.
Classe d'hôte:
La classe qui crée un fil pour les demandes est principalement en ouvrant un nouveau fil, en appelant la poignée d'assistance et en passant le texte à imprimer.
classe publique hôte {private final helper helper = new helper (); public void request (final int count, final char c) {System.out.println ("request start"); new thread () {public void run () {helper.handle (count, c);}}. start (); system.out.println ("request end");}}Classe d'aide:
Fournit la fonction d'affichage des caractères, la méthode lentement simule le temps d'impression
classe publique Helper {public void handle (int count, char c) {System.out.println ("Handle Method start"); for (int i = 0; i <count; i ++) {lentement (); System.out.print (c);} System.out.println (""); System.out.print ("Handy Method End");} private Void () {essai {essai { {Thread.Sleep (100);} Catch (InterruptedException e) {// TODO GÉNÉRÉ AUTO GÉNÉRÉ BLOCKE.PRINTSTACKTRACE ();}}}Classe principale:
Créez une instance d'hôte et appelez la méthode de demande
public static void main (String [] args) {System.out.println ("Main Begin"); host host = new host (); host.request (10, 'a'); host.request (20, 'b'); host.request (30, 'C'); System.out.println ("Main End");};};Résultats des tests:
Début principal
La méthode de demande a commencé
La fin de la méthode de demande
La méthode de demande a commencé
La fin de la méthode de demande
La méthode de demande a commencé
La fin de la méthode de demande
fin principale
Démarrer la méthode de la poignée
Démarrer la méthode de la poignée
Démarrer la méthode de la poignée
Bacbacbacbacbacbacbacbacbacba
Méthode de fin de poignée
Cbcbcbcbcbcbcbcbcbcbcbcbcbcbcbcbcb
Méthode de fin de poignée
CCCCCCCCCCC
Méthode de fin de poignée
À partir des résultats de l'opération, nous pouvons voir que la méthode de demande n'attend pas l'exécution de la méthode de poignée avant l'exécution, mais appelle la méthode de poignée et revient à la méthode de demande jusqu'à la fin de l'exécution. Par conséquent, il est équivalent à la méthode de requête en passant le travail d'impression d'un certain nombre de caractères à effectuer sur la méthode de la poignée, et la méthode de demande peut exécuter d'autres instructions dans la méthode stupide sans attendre que la méthode de poignée se termine. Cela nous indique également que lorsque certains travaux prennent du temps, de nouveaux threads peuvent être démarrés dans ce mode pour effectuer un traitement. Ce mode peut être appliqué au serveur, ce qui peut réduire le temps de réponse du serveur.
Expliquez le processus et le fil:
La plus grande différence entre les fils et les processus est de savoir si la mémoire coexiste.
Chaque processus a son propre espace mémoire indépendant. Un processus ne peut pas lire et écrire la mémoire d'autres processus sans autorisation. Étant donné que l'espace mémoire des processus est indépendant les uns des autres, un processus n'a pas à s'inquiéter d'être détruit par d'autres processus.
Les threads peuvent coexister. Un thread écrit du contenu sur l'instance, et d'autres threads peuvent lire le contenu de l'instance. Étant donné que plusieurs threads peuvent accéder à la même instance, nous devons nous assurer qu'il fonctionne correctement en mutex.
Optimisation de la conception de l'hôte:
1. Concevez la classe hôte à l'aide de l'interface ThreadFactory sous le package java.util.concurrent
Classe publique Hôte {Public Void Request (Final Int Count, Final Char C) {System.out.println ("La méthode de la demande démarre"); threadfactory.newthread (new Runnable () {@OverRidePublic Void run () {// TODO Auto-généré par Stubhelper.Trint. se termine ");}}Objet d'instanciation hôte correspondant:
Host host = new host (exécuteurs.defaultThreadFactory ());
L'avantage de cette conception est que le code d'instance original créé avec New dépend de la classe java.lang.thread, et ne peut pas contrôler la partie du thread de création et est moins réutilisable. Si ThreadFactory est utilisé pour enregistrer les objets de la classe correspondante et appeler la méthode NewThread pour créer un nouveau thread, la création de thread est réalisée. Cela ne dépend plus de la classe de threads, mais dépend de l'objet ThreadFactory passé dans le constructeur, qui met en œuvre les détails du contrôle de la création de threads.
Repenser la classe hôte à l'aide de l'interface java.util.concurrent.executor:
L'interface ThreadFactory précédente masque les détails de la création de threads, mais ne masque pas les opérations de création de thread. Si l'interface exécuteur est utilisée, les opérations de création de thread seront également masquées.
classe publique hôte {private final helper helper = new helper (); private final exécutor exécuteur; hôte public (exécuteur testamentaire exécuteur) {this.executor = exécuteur;} requête publique void (final compte, final char c) {System.out.println ("la méthode de la demande a démarré"); exécutor.execute (new runnable () {@OverridePubl Stubhelper.Handle (Count, C);}}); System.out.println ("Demande Méthode End");}}Créé à l'aide de java.util.concurrent.ScheduleDExecutorService Class, qui peut implémenter une opération planifiée
classe publique hôte {private final helper helper = new helper (); private final scheduledexEcutorService scheduledexECUTOrService; hôte public (scheduledexECUTOrService scheduledexECUTOrService Démarré "); ScheduleDExECUTORService.schedule (new Runnable () {@OverridePublic void run () {// TODO, méthode générée automatique Stubhelper.handle (count, c);}}, 3l, timeunit.secondes); System.out.println (" demande de méthode de demande ");}}}Testez l'entrée de la fonction principale:
ScheduleDExECUTORSService ScheduleDExECUtOrService = Exécutors.NewScheduledThreadpool (5); host host = new host (scheduledexECUTORService); try {host.request (10, 'a'); host.request (20, 'b'); host.request (30, 'c');} catch (exception e) {// to ale BLOCKE.PRINTSTACKTRACE ();} Enfin {ScheduleDExECUTORService.shutdown (); System.out.println ("Main End");}Résumer
Le rôle client appelle la méthode de demande du rôle d'hôte et le traitement réel de la demande est remis à la poignée d'assistance pour l'exécution. Cependant, si le client appelle la méthode de poignée directement à partir de la demande, il ne peut pas être renvoyé de la méthode de poignée tant que l'opération réelle n'est pas terminée. Cela réduira les performances de réponse de la demande. Par conséquent, le rôle de l'hôte lancera un nouveau thread utilisé pour traiter la demande du rôle du client et permettra au thread d'appeler la poignée, afin que le threadage de faire la demande puisse immédiatement revenir de la poignée. Il s'agit du mode thread-per-message.