Item Ne dépend pas du planificateur de threads

1. Le rôle du planificateur de threads

Le planificateur de threads détermine quels threads peuvent s'exécuter et pendant combien de temps. Les politiques de mise à l’échelle varient selon les systèmes d’exploitation. Il est crucial de ne pas dépendre du comportement du planificateur pour garantir l'exactitude ou les performances de votre programme, car cela compromet la portabilité.

2. Stratégies pour des programmes robustes : équilibrage des threads

Pour créer des programmes robustes, conservez un nombre de threads exécutables proche du nombre de processeurs disponibles. Cela évite de surcharger le planificateur et garantit un comportement cohérent. Bien que le nombre total de threads puisse être plus élevé, les threads en attente (non exécutables) n'ont pas d'impact significatif sur la charge du système.

3. Techniques de gestion des threads : éviter l'attente active et la mise à l'échelle

Évitez l'attente chaude, où un thread vérifie constamment l'état d'une ressource partagée. Cela consomme inutilement des ressources processeur. Réduisez le nombre de threads exécutables en dimensionnant correctement les pools de threads (comme dans Executor Framework) et en créant des tâches de taille appropriée – pas si petites que la surcharge prévaut, pas si grandes que le parallélisme soit empêché.

4. Exemple de mauvaise pratique : Espoir actif

Le code ci-dessous démontre l'attente active :

<code class="language-java">public class SlowCountDownLatch {
    private int count;

    public SlowCountDownLatch(int count) {
        this.count = count;
    }

    public void await() {
        while (count > 0) {
            // Espera-ativa: desperdício de recursos do processador
        }
    }

    public void countDown() {
        if (count > 0) {
            count--;
        }
    }
}</code>

Ce code consomme des ressources excessives. La solution est d'utiliser CountDownLatch, qui utilise des mécanismes de blocage efficaces.

5. Éviter Thread.yield()

La méthode Thread.yield() est incohérente entre les différentes implémentations JVM et ne fournit pas de solution robuste ou portable aux problèmes de concurrence. Au lieu d'utiliser Thread.yield(), restructurez le code pour réduire le nombre de threads exécutables.

Exemple incorrect :

<code class="language-java">while (!condition) {
    Thread.yield(); // Incorreto: uso de Thread.yield()
}</code>

6. Ajustement de la priorité du fil

L'ajustement des priorités des threads n'est pas non plus très portable, variant entre les systèmes d'exploitation et les JVM. Son utilisation doit être limitée à des scénarios précis où l'amélioration de la qualité de service justifie la perte de portabilité, et jamais comme solution à des problèmes structurels.

7. Conclusions

Ne dépendez pas du planificateur pour corriger ou optimiser les performances de votre programme. Évitez l'utilisation de Thread.yield() et les ajustements de priorité excessifs. La meilleure approche consiste à restructurer vos applications pour maintenir un nombre équilibré de threads exécutables.

---

Exemple tiré du livre :

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!