Quels sont les moyens de créer du multi-threading en Java ?
- PHPzavant
- 2023-04-26 16:07:192162parcourir
Cinq façons de créer des multi-threads en Java
(1) Hériter du Classe de fil
1. Description de l'implémentation
En héritant de Thread et en réécrivant 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 Méthode start( )
3. Implémentation du code
4. Remarque
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.
L'utilisation de la classe thread qui implémente l'interface Runnable pour créer des objets peut 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 Les objets de la classe Thread et les objets de la classe UserRun sont utilisés comme paramètres du constructeur de la classe Thread
5) Démarrez le fil de discussion
3. Implémentation du code
4. Remarque
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'objet Thread. Interface exécutable.
La solution à ce problème est d'introduire l'interface Future. Cette interface peut accepter la valeur de retour de call(). L'interface future et l'interface Runnable peuvent être utilisées 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 UserCallable
4) Créer l'interface RunnableFuture L'objet de la sous-classe FutureTask, le paramètre du constructeur est l'objet de UserCallable
5) Créer un objet de la classe Thread, le paramètre du constructeur est l'objet de FutureTask
6) Démarrez le fil de discussion
- 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
.
- Les classes timer 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
Les threads créés par la classe timer sont davantage utilisés 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 leurs propres tâches.
(5) Démarrez le multithread via le pool de threads
1. Description de l'implémentation
Des 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 utilisez le pool de threads pour effectuer des tâches
③Shutdown() ferme le pool de threads
(2) Implémentation du code
(3) Notes
Créez un pool de threads de taille fixe pour réaliser partage de ressources de données, plusieurs threads travaillent ensemble pour accomplir une tâche.
2) Pool monothread SingleThreadExecutor( )
(1) Étapes spécifiques
① Créez un pool monothread via Executors.newSingleThreadExecutor( )
② Remplacez la méthode run( ) de la classe Runnable et utilisez la 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( )
② Remplacez la méthode run( ) de la classe Runnable et utilisez des threads Tâche d'exécution du pool
③ 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, 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 (nombre minimum de threads à maintenir, aucun thread sera créé après la création du thread Recyclé), le pool de threads est exécuté 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() ferme le pool de threads
(2) Implémentation du code
(3) Précautions
Création Un pool de threads périodiques qui prend 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 provoquer un déséquilibre de charge du processeur. Cette méthode peut effectivement 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.
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!