Un guide pratique du modèle de programmation concurrentielle de base JAVA

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.

1. Bases du Threading
   Tout d'abord, jetons un coup d'œil à l'élément de programmation simultanée le plus basique en JAVA : les threads. Les threads en JAVA sont représentés par la classe java.lang.Thread. Voici un exemple de fil simple :

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.

2. Interface Runnable
   En plus d'hériter de la classe Thread, nous pouvons également implémenter l'interface java.lang.Runnable pour créer des threads. Voici un exemple d'utilisation de l'interface Runnable :

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.

3. Thread Pool
   Dans la programmation simultanée réelle, la création et la destruction fréquentes de threads entraîneront une surcharge de performances importante. Par conséquent, JAVA fournit un pool de threads pour gérer et réutiliser les threads. Voici un exemple simple d'utilisation d'un pool de threads :

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.

4. Verrous et synchronisation
   En programmation simultanée, les verrous et la synchronisation sont des concepts très importants. JAVA fournit le mot-clé synchronisé et l'interface Lock pour nous aider à réaliser la synchronisation entre les threads. Voici un exemple d'utilisation du mot-clé synchronisé :

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.

5. Collections simultanées
   Afin de partager des données en toute sécurité dans la programmation simultanée, JAVA fournit des classes de collection sécurisées pour la concurrence, telles que ConcurrentHashMap et CopyOnWriteArrayList. Voici un exemple d'utilisation de ConcurrentHashMap :

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!