Executor Framework est un outil de concurrence en Java pour simplifier la gestion des threads et la planification des taches, et son noyau est de découpler la soumission des taches à partir de l'exécution. 1. Les raisons de l'utilisation de l'exécuteur au lieu de nouveau thread () incluent d'éviter les ressources hors de contr?le, d'améliorer les performances, d'implémenter la réutilisation du thread et la gestion unifiée; 2. Les principales interfaces sont l'exécuteur exécuteur et l'exécution de l'interface d'extension, qui prend en charge la soumission des taches, la gestion du cycle de vie et les résultats futurs de retour; 3. Les types de piscines de fil conducteur incluent NewFixEdThreadpool, NewCachedThreadpool, NewsingLethreAdExecutor et NewscheduLedThreadPool, qui conviennent à différents scénarios; 4. Il est recommandé de créer manuellement ThreadPoolExecutor et de définir clairement CorePoolSize, MaximumpoolSize, KeepaliveTime, WorkQueue, ThreadFactory et RejectEdExecutionHandler paramètres; 5. La file d'attente des taches doit être prioritaire aux files d'attente délimitées telles que ArrayBlockingQueue pour empêcher l'OOM; 6. La politique de rejet comprend une abordation, Callersepolicy, Discardpolicy et DiskeroldestPolicy, qui devrait être sélectionnée selon les besoins de l'entreprise; 7. Lors de la soumission de taches, vous pouvez utiliser Runnable (pas de valeur de retour) ou callable (avec valeur de retour) pour obtenir des objets futurs via la méthode de soumission; 8. Lors de la fermeture du pool de threads, vous devez d'abord appeler Shutdown (), puis combiner awittermination () et shutdownnow () pour assurer un temps d'arrêt élégant; 9. Les meilleures pratiques incluent l'évitement de l'utilisation des méthodes de raccourci des exécuteurs, des paramètres de configuration explicites, du pool de threads nommé, un réglage raisonnable du nombre de threads, du pool de threads de cl?ture en temps opportun et de la gestion des exceptions dans Runnable. L'utilisation correcte du cadre de l'exécuteur peut éviter efficacement les problèmes d'épuisement des ressources et de performances et est la base de la création d'applications Java à haute concurrence.

La programmation simultanée en Java est souvent un mal de tête, et le livre "Java Concurrence in Practice" est connu sous le nom de "Bible" de la programmation simultanée. L'explication de l'exécuteur exécuteur (Frame d'exécuteur) est un lien clé pour comprendre le développement multi-thread Java moderne. Il nous permet de nous débarrasser du lourd et du risque de threads (threads) de fonctionnement directement et d'utiliser à la place des abstractions de niveau supérieur pour gérer l'exécution des taches.

Qu'est-ce que le cadre de l'exécuteur?

Le cadre exécuteur est un ensemble d'API introduit dans Java 5 pour simplifier la gestion des threads et la planification des taches, et le noyau est situé dans java.util.concurrent . Son objectif de conception est de découpler la soumission des taches de l'exécution des taches .

L'interface la plus principale est Executor :

 Exécuteur de l'interface publique {
    void EXECUTE (Commande Runnable);
}

Ne le regardez pas simplement, il y a une puissante idée de conception derrière: vous n'avez qu'à soumettre la tache, et comment l'exécuter (quel thread est utilisé, qu'il soit réutilisé, ou s'il est asynchrone) est déterminé par la classe d'implémentation.

Ce qui est plus couramment utilisé, c'est son interface d'extension: ExecutorService , qui prend en charge la gestion du cycle de vie, le résultat de retour de soumission des taches (futur), la fermeture élégante, etc.

Pourquoi utiliser l'exécuteur au lieu de nouveau thread ()?

Utilisation new Thread(runnable).start() semble directement simple, mais il y a des problèmes évidents:

• Ressources incontr?lables : chaque fois qu'une tache arrive, un fil est créé et les ressources système sont rapidement épuisées.
• Manque de gestion : le nombre de concurrence ne peut pas être limité, le nombre de threads ne peut pas être réutilisé et la surveillance ne peut pas être unifiée.
• Performances médiocres : des frais généraux élevés pour la création de filetages et la destruction.

Les avantages de l'utilisation du cadre de l'exécuteur comprennent:

• ? Réutilisation du thread (via le pool de threads)
• ? Contr?lez le nombre de
• ? Améliorez la vitesse de réponse (la tache est exécutée directement lorsqu'il s'agit, sans attendre la création de thread)
• ? Gestion des exceptions unifiées et gestion des ressources
• ? Prise en charge des taches planifiées et périodiques (ScheduleDExEcutorService)

Types de pool de threads communs (créé via la classe d'outils exécuteurs)

Bien que Executors fournissent une méthode pratique, il est recommandé de créer manuellement ThreadPoolExecutor pour clarifier les paramètres de la production réelle. Mais comprenez d'abord les types communs:

Exemple:

 ExecutorService exécutor = exécutor.NewFixEdThreadPool (4);

pour (int i = 0; i <10; i) {
    EMECTOR.EXECUTE (() -> {
        System.out.println ("Tache exécutée par" thread.currentThread (). GetName ());
    });
}

// N&#39;oubliez pas de fermer EMIRMETOR.SHUTDOWN ();

Explication détaillée des composants clés

1. Paramètres centraux de ThreadpoolExecutor

Il est plus s?r de créer un pool de threads manuellement, avec les paramètres clés comme suit:

 Nouveau threadpoolexecutor (
    CorePoolSize, // Nombre de threads de base (résident)
    MaximumpoolSize, // Nombre maximum de threads keepalivetime, // unité de temps de survie sans fil non coré, // unité de temps workqueue, // file d'attente de tache (comme LinkedBlockingQueue, ArrayBlockingQueue)
    ThreadFactory, // Factory de création de threads (personnalisable)
    RejectEdExecutionHandler // Rejeter la politique);

?? Remarque: Executors.newFixedThreadPool() utilise une file d'attente non liée ( LinkedBlockingQueue ), qui peut provoquer un débordement de mémoire (OOM). Utilisez-le avec prudence dans l'environnement de production.

2. Sélection de la file d'attente des taches

• ArrayBlockingQueue : Fitre délimitée, recommandée, empêcher l'épuisement des ressources
• LinkedBlockingQueue : file d'attente illimité, facile à remplir la mémoire
• SynchronousQueue : Aucun éléments n'est stocké, chaque insert doit attendre le retrait (convient à newCachedThreadpool)
• PriorityBlockingQueue : prend en charge les files d'attente de taches prioritaires

3. Gestionnaire d'exécution rejeté

Lorsque le pool de threads est fermé ou que la file d'attente est pleine, la nouvelle tache est refusée. Stratégies courantes:

• AbortPolicy : lancer RejectedExecutionException (par défaut)
• CallerRunsPolicy : le fil qui soumet la tache elle-même (ralentit la vitesse de validation)
• DiscardPolicy : jetez silencieusement les taches
• DiscardOldestPolicy : jetez la tache la plus ancienne de la file d'attente et essayez de se soumettre à nouveau

Il est recommandé d'utiliser des alertes logarithmiques AbortPolicy basées sur des choix commerciaux, tels que l'utilisation de journaux abortpolicy à l'alerte, et les taches non critiques peuvent être rejetées.

Comment soumettre des taches: Runnable vs Callable

• execute(Runnable) : pas de valeur de retour
• submit(Runnable) : renvoie Future<?> , qui peut être utilisé pour déterminer s'il est terminé
• submit(Callable<T>) : Retour Future<T> pour obtenir la valeur de retour ou l'exception

 Futur <Integer> futur = exécutor.sumit (() -> {
    retour 42;
});

Résultat entier = futur.get (); // bloque et attendez le résultat

Vous pouvez également utiliser invokeAll() pour soumettre plusieurs callables en lots, ou invokeAny() pour retourner le premier résultat terminé.

Comment fermer élégamment la piscine de fil?

Direct shutdown() ne suffit pas, il est recommandé:

 exécuteur.shutdown (); // Aucune nouvelle tache n'est re?ue, essayez {
    if (! exécutor.awampitring (60, timeunit.seconds)) {
        exécuteur.shutdownNow (); // Essayez d'interrompre la tache d'exécution}
} catch (InterruptedException e) {
    exécuteur.shutdownNow ();
    Thread.currentThread (). Interrupt ();
}

Cela garantit que le pool de threads a suffisamment de temps pour effectuer les taches existantes avant la sortie de l'application.

Résumé: recommandations de meilleures pratiques

• ? évitez d'utiliser la méthode de raccourci Executors pour créer des pools de threads (en particulier les files d'attente illimitées)
• ? Utilisez ThreadPoolExecutor pour configurer explicitement les paramètres pour clarifier la taille de la file d'attente et rejeter la stratégie
• ? Nommez le pool de threads (via ThreadFactory ) pour faciliter le dépannage
• ? Réglez corePoolSize et maxPoolSize raisonnables, combiné avec un ajustement de mesure de la pression
• ? N'oubliez pas de fermer le pool de threads pour éviter la fuite des ressources
• ? Gestion des exceptions: Runnable a besoin d'essayer une prise en interne en interne, sinon l'exception "dispara?tra"

Fondamentalement, c'est tout. L'exécuteur Framework résume la gestion complexe des threads dans une interface concise et est la pierre angulaire de la programmation simultanée Java moderne. La compréhension non seulement d'écrire du code plus robuste, mais évitera également de nombreux problèmes en ligne tels que "fil complet", "CPU en flèche" et "débordement de mémoire".

Pas compliqué, mais il est facile d'ignorer les détails.

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!