Cinq façons ! Résumé de la création de multi-threads en Java

Cet article vous apporte des connaissances pertinentes sur java. Il résume et présente principalement cinq méthodes de création de multi-threads, notamment l'héritage de la classe Thread, l'implémentation de l'interface Runnable, l'implémentation de l'interface Callable, l'héritage de la classe TimerTask et le passage des threads au démarrage du pool. multi-threading, j'espère que cela aidera tout le monde.

Étude recommandée : "Tutoriel d'apprentissage Java"

Cinq façons de créer des multi-threads en Java

• Ceci est uniquement pour la communication et l'apprentissage de la programmation Java. Si vous avez des questions, n'hésitez pas à nous contacter. éclaire-moi. Bienvenue à ajouter et à communiquer, veuillez l'indiquer lors de la réimpression !

(1) Hériter de la classe Thread

1. Description de l'implémentation

• En héritant de Thread et en remplaçant son run(), les tâches qui doivent être effectuées sont définies dans la méthode run. La sous-classe créée peut exécuter la méthode thread en appelant la méthode start().
• En héritant de la classe thread implémentée par Thread, les variables d'instance de la classe thread ne peuvent pas être partagées entre plusieurs threads. Différents objets Thread doivent être créés et les ressources ne sont naturellement pas partagées.

2. Étapes spécifiques

1) Définir la classe UserThread et hériter de la classe Thread
2) Remplacer la méthode run()
3) Créer un objet UserThread
4) Appeler la méthode start()

3. Implémentation du code

4. Notes

• Les ressources de données ne sont pas partagées et plusieurs threads effectuent leurs propres tâches. Par exemple, si trois guichets vendent des billets en même temps et que chacun vend son propre billet, il y aura un problème avec trois guichets vendant le même billet.

(2) Implémenter l'interface Runnable

1. Description de l'implémentation

• Vous devez d'abord définir une classe pour implémenter l'interface Runnable et remplacer la méthode run() de l'interface. Cette méthode run est le corps d'exécution du thread. Créez ensuite un objet de la classe d'implémentation Runnable comme cible de paramètre pour créer l'objet Thread. Cet objet Thread est le véritable objet thread.
• Utilisez la classe de thread qui implémente l'interface Runnable pour créer des objets afin de réaliser le partage de ressources entre les threads.

2. Étapes spécifiques

1) Définir une classe UserRun et implémenter l'interface Runnble
2) Remplacer la méthode run()
3) Créer un objet de la classe UserRun
4) Créer un objet de la classe Thread, et l'objet du La classe UserRun sert de constructeur aux paramètres de la classe Thread
5) Démarrer le fil

3. Implémentation du code

4. Notes

• Partage des ressources de données, plusieurs threads accomplissent une tâche ensemble (plusieurs threads partagent les ressources pour créer des objets de thread). Par exemple, trois guichets de tickets (trois threads) vendent des tickets en même temps (ticket dans la classe MyThread), et les trois threads utilisent des ressources ensemble.

(3) Implémenter l'interface Callable

1. Description de l'implémentation

• L'interface Callable est comme une version améliorée de l'interface Runable. La méthode call() qu'elle fournit servira de corps d'exécution du thread et permettra une valeur de retour.
• L'objet Callable ne peut pas être directement utilisé comme cible de l'objet Thread, car l'interface Callable est une nouvelle interface en Java5 et n'est pas une sous-interface de l'interface Runnable.
• La solution à ce problème est d'introduire l'interface Future. Cette interface peut accepter la valeur de retour de call(). L'interface RunnableFuture est une sous-interface de l'interface Future et de l'interface Runnable et peut être utilisée comme cible de. l'objet Thread.

2. Étapes spécifiques

1) Définir la classe UserCallable et implémenter l'interface Callable
2) Remplacer la méthode call()
3) Créer un objet de UserCallable
4) Créer un objet de FutureTask, une sous-classe de l'interface RunnableFuture, et le le paramètre du constructeur est l'objet de UserCallable
5) Créez un objet de la classe Thread, et le paramètre du constructeur est l'objet de FutureTask
6) Démarrez le fil

3. Implémentation du code

4. Notes

• Partage des ressources de données, plusieurs threads accomplissent une tâche ensemble (plusieurs threads partagent les ressources pour créer des objets de thread). Par exemple, trois guichets de tickets (trois threads) vendent des tickets en même temps (ticket dans la classe MyThread), et les trois threads utilisent des ressources ensemble. En même temps, une fois l'appel du fil terminé, il y aura une valeur de retour.

(4) Hériter de la classe TimerTask

1. Description de l'implémentation

• Les classes de minuterie Timer et TimerTask peuvent être utilisées comme un autre moyen d'implémenter des threads.
• Timer est une fonction de thread utilisée pour planifier des tâches pour une exécution ultérieure dans un thread en arrière-plan. La tâche peut être programmée pour être exécutée une ou plusieurs fois à intervalles réguliers. Elle peut être considérée comme une minuterie et TimerTask peut être planifiée.
• TimerTask est une classe abstraite qui implémente l'interface Runnable, elle possède donc des capacités multithread.

2. Étapes spécifiques

1) Définir la classe UserTimerTask et hériter de la classe abstraite TimerTask
2) Créer un objet de la classe UserTask
3) Créer un objet de la classe Timer et définir la stratégie d'exécution de la tâche

3. Implémentation du code

4． Notes

• Le thread créé par la classe timer est davantage utilisé pour le traitement des tâches planifiées, et les ressources de données ne sont pas partagées entre les threads, et plusieurs threads effectuent respectivement leurs propres tâches.

(5) Démarrez plusieurs threads via le pool de threads

1. Description de l'implémentation

• Les pools de threads peuvent être créés via la classe d'outils Executors.
• Améliorez la vitesse de réponse du système. Lorsqu'une tâche arrive, en réutilisant le thread existant, elle peut être exécutée immédiatement sans attendre la création d'un nouveau thread.
• Réduisez la consommation des ressources système et réduisez la consommation causée par la création et la destruction de threads en réutilisant les threads existants.
• Pratique pour contrôler le nombre de threads simultanés. Parce que si les threads sont créés sans limite, cela peut provoquer un MOO en raison d'une utilisation excessive de la mémoire et entraîner une commutation excessive du processeur.

2. Méthode d'implémentation

1) FixThreadPool (int n) pool de threads de taille fixe

(1) Étapes spécifiques

① Créez un pool de threads de taille fixe via Executors.newFixedThreadPool(5)
② Remplacez la méthode run( ) du Classe exécutable et utilise le pool de threads pour effectuer des tâches
③Shutdown() ferme le pool de threads

(2) Implémentation du code

(3) Notes

• Créer un pool de threads de taille fixe, qui peut réaliser le partage de ressources de données. Plusieurs threads travaillent ensemble pour accomplir une tâche.

2) Pool de threads uniques SingleThreadExecutor( )

(1) Étapes spécifiques

① Créez un pool de threads uniques via Executors.newSingleThreadExecutor( )
② Remplacez la méthode run( ) de la classe Runnable et utilisez le pool de threads pour exécuter des tâches
③Shutdown() ferme le pool de threads

(2) Implémentation du code

(3) Notes

• Le pool de threads ne crée qu'un seul thread pour effectuer la tâche.

3) Pool de threads de cache CachedThreadPool()

(1) Étapes spécifiques

①Créez autant de pools de threads que possible via Executors.newCachedThreadPool()
②Réécrivez la méthode run() de la classe Runnable et utilisez le pool de threads Execute la tâche
③Shutdown() ferme le pool de threads

(2) Implémentation du code

(3) Notes

• Cette méthode créera autant de threads que possible pour terminer la tâche, comme dans le cas, bien qu'il n'y ait que 10 tickets, mais le pool de threads a généré au moins 12 threads.

4) ScheduledThreadPool(int n) pool de threads périodiques planifiés

(1) Étapes spécifiques

① Utilisez Executors.newScheduledThreadPool(5) pour créer un nombre fixe de threads principaux (le nombre minimum de threads à maintenir, le thread ne sera pas supprimé après la création du pool de threads Recyclage), les threads sont exécutés régulièrement comme prévu.
②　Réécrivez la méthode run() de la classe Runnable et utilisez le pool de threads pour effectuer des tâches
③Shutdown() pour fermer le pool de threads

(2) Implémentation du code

(3) Notes

• Créez un pool de threads périodiques pour prendre en charge l'exécution planifiée et périodique des tâches (le premier paramètre de temps est le délai d'exécution et le deuxième paramètre est l'intervalle d'exécution).

5) Extension WorkStealingPool() de la nouvelle classe de pool de threads ForkJoinPool

(1) Étapes spécifiques

① Créez un pool de threads via Executors.newWorkStealingPool()
② Réécrivez la méthode run() de la classe Runnable, via la classe Thread L'objet appelle l'objet de classe Runnable et utilise le pool de threads pour effectuer la tâche
③Sleep() permet au thread principal d'attendre que le thread enfant termine son exécution, ou vous pouvez utiliser un compteur
④Shutdown() pour fermer le pool de threads

(2) Implémentation du code

(3) Notes

• Parce que chaque thread a sa propre file d'attente de tâches, comme il y a de plus en moins de tâches, cela peut entraîner un déséquilibre de la charge du processeur. Cette méthode peut efficacement tirer parti des avantages des processeurs multicœurs. Les threads avec moins de tâches peuvent « voler » les tâches des threads avec plus de tâches, équilibrant ainsi l'exécution des tâches sur chaque processeur.

Apprentissage recommandé : "Tutoriel Java"

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!