Guide pratique du modèle de programmation simultanée JAVA Core
Dans le domaine du développement logiciel actuel, les processeurs multicœurs et les systèmes distribués sont devenus courants. Afin d'utiliser pleinement les ressources matérielles, nous devons écrire des programmes simultanés pour réaliser un traitement parallèle et améliorer les performances. En tant que langage de programmation courant, JAVA fournit un riche ensemble de modèles et d'outils de programmation simultanée. Cet article vous amènera à avoir une compréhension approfondie des principaux modèles de programmation simultanée de JAVA à travers quelques exemples de code spécifiques, et à apprendre à utiliser ces modèles pour pratiquer la programmation simultanée.
public class MyThread extends Thread { @Override public void run() { System.out.println("Hello, this is my thread!"); } public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); } }
Dans cet exemple, nous créons une classe de fil personnalisée MyThread qui hérite de Thread et réécrivons la méthode run pour afficher un message simple dans la méthode run. Dans la méthode principale, nous créons une instance de MyThread et démarrons le thread via la méthode start.
public class MyRunnable implements Runnable { @Override public void run() { System.out.println("Hello, this is my runnable!"); } public static void main(String[] args) { Thread myThread = new Thread(new MyRunnable()); myThread.start(); } }
Dans cet exemple, nous avons créé une classe personnalisée MyRunnable qui implémente l'interface Runnable et remplacé la méthode run. Dans la méthode principale, nous créons un objet Thread, passons l'instance de MyRunnable en tant que paramètre et démarrons le thread via la méthode start.
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(3); for (int i = 0; i < 5; i++) { Runnable worker = new WorkerThread("" + i); executor.execute(worker); } executor.shutdown(); while (!executor.isTerminated()) { } System.out.println("Finished all threads"); } } class WorkerThread implements Runnable { private String message; public WorkerThread(String s) { this.message = s; } public void run() { System.out.println(Thread.currentThread().getName() + " (Start) message = " + message); processMessage(); System.out.println(Thread.currentThread().getName() + " (End)"); } private void processMessage() { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }
Dans cet exemple, nous utilisons la classe utilitaire Executors pour créer un pool de threads d'une taille fixe de 3. Ensuite, nous avons créé 5 instances de WorkerThread et les avons soumises au pool de threads. Le pool de threads sera chargé de gérer l'exécution de ces threads.
public class Counter { private int count = 0; public synchronized void increment() { count++; } public synchronized void decrement() { count--; } public synchronized int getCount() { return count; } }
Dans cet exemple, nous avons créé une classe Counter, dans laquelle les méthodes incrément, décrémentation et getCount utilisent toutes le mot-clé synchronisé pour réaliser la synchronisation. Cela garantit que les appels à ces méthodes à partir de plusieurs threads sont sécurisés.
De plus, le package de concurrence de JAVA fournit également plusieurs implémentations de verrouillage, telles que ReentrantLock et ReadWriteLock. Voici un exemple d'utilisation de ReentrantLock :
import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockExample { private final ReentrantLock lock = new ReentrantLock(); public void performTask() { lock.lock(); try { // 执行需要同步的代码块 } finally { lock.unlock(); } } }
Dans cet exemple, nous créons une instance de ReentrantLock et utilisons lock et unlock pour verrouiller et déverrouiller la section critique. Cette méthode est plus flexible que le mot-clé synchronisé et permet de contrôler manuellement l'acquisition et la libération des verrous.
import java.util.concurrent.ConcurrentHashMap; public class ConcurrentMapExample { private ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>(); public void addKeyValuePair(String key, String value) { map.put(key, value); } public String getValueByKey(String key) { return map.get(key); } }
Dans cet exemple, nous créons une instance ConcurrentHashMap et utilisons les méthodes put et get pour manipuler en toute sécurité les données de la carte sans nécessiter d'opérations de synchronisation supplémentaires.
Grâce aux exemples ci-dessus, nous avons une compréhension approfondie du modèle de programmation simultanée de base de JAVA, y compris les bases des threads, les pools de threads, les verrous et la synchronisation, ainsi que les collections simultanées. Dans les projets réels, une utilisation raisonnable de ces modèles de programmation simultanée peut améliorer les performances et la stabilité du programme. J'espère que cet article pourra aider les lecteurs à mieux maîtriser les connaissances de la programmation simultanée en JAVA et à écrire des programmes simultanés efficaces dans la pratique.
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!