Le c?ur de la ma?trise de la concurrence Java est de comprendre l'interaction du fil, les risques d'état partagés et les mécanismes de coordination, plut?t que de mémoriser l'API uniquement. 1. Comprendre la différence entre le thread et le runnable, hiérarchisez l'implémentation de Runnable ou Callable, et utilisez ExecutorService pour gérer les threads pour améliorer l'utilisation et l'évolutivité des ressources; 2. Empêcher les conditions de course pour les variables partagées sous plusieurs threads via des mots-clés synchronisés ou atomicInteger, et utilisez des CAS pour obtenir un fonctionnement sans serrure efficace; 3. Utilisez des collections en filetage telles que ConcurrentHashMap, CopyOnwriteArrayList et BlockingQueue pour éviter la corruption des données, en particulier BlockingQueue, peut simplifier la coordination de blocage des modèles de consommation producteur; 4. évitez les blocs de blocage pour obtenir des verrous dans un ordre fixe, ou utilisez Reentrantlock pour coopérer avec le mécanisme de délai d'expiration pour réduire les risques d'attente illimités; 5. Volatile garantit une visibilité variable mais ne garantit pas l'atomicité. Il convient aux bits de drapeau. Les opérations composées nécessitent toujours une classe atomique ou un contr?le de synchronisation; 6. La priorité est accordée à l'utilisation d'outils de concurrence avancés tels que CountdownLatch, CyclicBarrier, Semaphore et CompecuableFuture pour améliorer la lisibilité et la fiabilité du code. Enfin, nous devons minimiser l'état variable partagé, adopter une conception immuable, un stockage à thread-local ou des flux réactifs et créer des programmes prévisibles et maintenables hautement simultanés basés sur la bibliothèque d'outils de concurrence JDK.

La ma?trise de la concurrence et du multithreading de Java ne concerne pas la mémorisation des API - il s'agit de comprendre comment les fils interagissent, comment l'état partagé peut briser votre programme et comment coordonner en toute sécurité et efficacement. Si vous construisez des applications Java haute performance, la concurrence est inévitable. Voici ce qui compte réellement.

1. Comprendre les concepts principaux: Thread vs Runnable

Commencez par conna?tre la différence entre Thread et Runnable . Bien que vous puissiez prolonger Thread , la meilleure pratique consiste à implémenter Runnable (ou Callable pour les valeurs de retour). Cela maintient votre logique de tache distincte de la gestion des threads.

 Runnable task = () -> System.out.println ("Running in:" Thread.currentThread (). GetName ());
Thread t = nouveau thread (tache);
t.start (); // N'appelle pas Run () directement

Key Insight: Call run() exécute directement le code sur le thread actuel. Utilisez toujours start() pour engendrer un nouveau fil.

Préférez également ExecutorService des fils bruts:

 ExecutorService exécutor = exécutor.NewFixEdThreadPool (4);
exécuteur.Submit (tache);
// N'oubliez pas d'arrêter
exécuteur.shutdown ();

Cela vous donne une réutilisation de discussion, une meilleure gestion des ressources et une évolutivité.

2. Garde contre les conditions de course avec une synchronisation appropriée

Lorsque plusieurs threads accèdent aux données mutables partagées, le chaos assure. Considérez ce problème classique:

 int counter = 0;
// plusieurs threads faisant:
comptoir ; // pas atomique!

L'incrément est de trois opérations: lire, incrémenter, écrire. Sans synchronisation, les threads peuvent se remplacer mutuellement.

Solutions:

• Utilisez un mot-clé synchronized :

   public synchronisé vide incrément () {
      comptoir ;
  }

• Utilisez java.util.concurrent.atomic Classes:

   ATOMICInteger Counter = New AtomicInteger (0);
  compter.incrementAndget (); // sans serrure, file

Les classes atomiques utilisent les instructions CAS (comparer-and-swap) de niveau CPU - rapide et efficace pour les opérations simples.

3. Choisissez les bonnes collections de filetage

Vous utilisez ArrayList ou HashMap sur les threads? Vous demandez ConcurrentModificationException ou une corruption silencieuse de données.

Plut?t:

• ConcurrentHashMap - carte simultanée haute performance
• CopyOnWriteArrayList - Bon pour les écritures de lecture et peu fréquentes
• Implémentations BlockingQueue ( LinkedBlockingQueue , ArrayBlockingQueue ) - Idéal pour les modèles producteurs-consommateurs

Exemple: producteur-consommateur avec BlockingQueue

 BlockingQueue <string> file d&#39;attente = nouveau LinkedBlockingQueue <> (10);

// producteur
Executor.Submit (() -> {
    pour (int i = 0; i <100; i) {
        queue.put ("item" i); // bloque si plein
    }
});

// consommateur
Executor.Submit (() -> {
    while (true) {
        essayer {
            String item = queue.take (); // bloque si vide
            System.out.println ("Consommé:" Article);
        } catch (InterruptedException e) {break; }
    }
});

Le comportement de blocage simplifie la coordination - aucun besoin de sonder ou de tourner.

4. évitez l'impasse avec une commande de verrouillage prudente

L'impasse se produit lorsque les threads attendent les verrouillage que les autres tiennent, pour toujours. Exemple classique: deux fils essayant d'acquérir deux serrures dans des ordres opposés.

Conseil de prévention: acquiert toujours des verrous dans un ordre mondial cohérent.

Mieux encore: évitez les blocs synchronized avec plusieurs serrures . Utilisez plut?t des outils de concurrence de niveau supérieur.

Ou utilisez java.util.concurrent.locks.ReentrantLock avec les délais:

 ReentrantLock Lock1 = new reentrantLock ();
ReentrantLock Lock2 = new reentrantLock ();

booléen acquise1 = lock1.trylock (1, timeunit.seconds);
booléen acquise2 = lock2.trylock (1, timeUnit.seconds);

if (acquired1 && acquised2) {
    essayer {
        // fonctionne
    } enfin {
        if (acquired2) lock2.unlock ();
        if (acquired1) lock1.unlock ();
    }
}

Cela évite en effet le blocage.

5. Utilisez volatile pour la visibilité, pas l'atomicité

Déclarer un volatile variable garantit que les changements sont immédiatement visibles pour d'autres threads, mais il ne rend pas les opérations composées atomiques.

 Running booléen volatile = true;

// Fil 1
while (running) {
    // fonctionne
}

// Fil 2
running = false; // Un autre fil verra ce changement

C'est parfait pour les drapeaux. Mais volatile int counter ne corrige pas counter .

Pour la visibilité et l'atomicité, utilisez AtomicInteger ou Synchronisation.

6. Préférer les services de concurrence de haut niveau

Le package java.util.concurrent de Java est plein d'outils testés au combat:

• CountDownLatch : attendez qu'un ensemble d'opérations termine
• CyclicBarrier : Laissez les fils attendre les uns les autres à un point de barrière
• Semaphore : contr?ler l'accès à un pool de ressources
• CompletableFuture : Composez les opérations asynchrones

Exemple: attendez que 3 services commencent

 CountdownLatch Latch = new CountdownLatch (3);

pour (int i = 0; i <3; i) {
    Executor.Submit (() -> {
        // Simuler Service Start
        Thread.Sleep (1000);
        latch.CountDown ();
    });
}

latch.Await (); // bloque jusqu&#39;à ce que les 3 appels à rebours ()
System.out.println ("Tous les services ont démarré.");

Ces outils sont plus clairs et plus s?rs que Manual wait() / notify() .

Réflexions finales

La ma?trise de la concurrence ne concerne pas la rédaction du code multithread le plus intelligent - il s'agit d'écrire le code le plus prévisible et le plus maintenable. Se concentrer sur:

• Minimiser l'état mutable partagé
• Utilisation de classes de filetage à partir de java.util.concurrent
• Préférer l'immuabilité et les conceptions de style fonctionnel
• Tests sous charge (les conditions de course n'apparaissent souvent que sous le stress)

Et rappelez-vous: si vous pouvez éviter un état partagé, faites-le . Parfois, la meilleure conception simultanée est celle qui évite de partager complètement le passage du message, le stockage de filetage ou les flux réactifs.

Fondamentalement, restez simple, testez soigneusement et appuyez sur la bo?te à outils de concurrence du JDK. C'est là pour une raison.

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!