Programmation multithread en Java

Programmation multithread en Java

Java est un langage de programmation largement utilisé dans le domaine du développement de logiciels, et la programmation multithread est un modèle de programmation courant en Java. La programmation multithread peut permettre à un programme d'effectuer plusieurs tâches en même temps, améliorant ainsi la concurrence et l'efficacité du programme. Cet article vous présentera la programmation multithread en Java.

Le concept de base du multi-threading

Le multi-threading fait référence à la capacité d'un programme à effectuer plusieurs tâches en même temps. Dans le cas d'un processeur monocœur, le multithreading est obtenu grâce au processeur qui passe rapidement d'une tâche à l'autre. Dans le cas des processeurs multicœurs, plusieurs tâches peuvent être exécutées simultanément sur différents cœurs de processeur.

Implémentation multithread en Java

Le multithreading en Java est implémenté en créant des objets de la classe Thread, qui fournit une implémentation de thread légère. Les threads peuvent être créés en héritant de la classe Thread ou en implémentant l'interface Runnable.

1. Hériter de la classe Thread

Hériter de la classe Thread est le moyen le plus simple de l'implémenter. Il vous suffit de créer une classe et d'hériter de la classe Thread, et de remplacer la méthode run() pour implémenter la fonctionnalité multi-threading. Comme indiqué ci-dessous :

public class MyThread extends Thread {

    @Override
    public void run() {
        // 运行多线程的函数代码
    }
}

Créez un objet de MyThread et appelez la méthode start() pour démarrer un nouveau thread :

MyThread thread = new MyThread();
thread.start();

2. Implémentez l'interface Runnable

L'implémentation de l'interface Runnable est également un moyen d'implémenter le multi-threading. Il doit implémenter la méthode run(), mais doit transmettre une instance d'interface Runnable au constructeur de la classe Thread. Comme indiqué ci-dessous :

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        // 运行多线程函数代码
    }
}

Créez et démarrez le thread de MyRunnable :

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

La classe Thread en Java fournit d'autres méthodes et propriétés pour surveiller et contrôler l'état et le comportement du thread, telles que join(), rendement() , méthodes sleep(), setPriority() et isAlive().

Synchronisation multithread

Dans la programmation multithread, plusieurs threads peuvent accéder à la même ressource. À ce stade, il est nécessaire d'assurer la synchronisation des threads et l'exclusion mutuelle pour empêcher plusieurs threads de modifier la même ressource en même temps, provoquant une confusion des données ou des erreurs. Java fournit une variété de méthodes de synchronisation :

1. Blocs de code synchronisés

Avec le mot-clé synchronisé, vous pouvez marquer une méthode ou un bloc de code comme synchronisé, de sorte qu'un seul thread entrant dans le bloc puisse y exécuter le code. Comme indiqué ci-dessous :

public class SynchronizedThread {
    // 定义一个计数器
    private int count = 0;

    // 定义同步的方法
    public synchronized void addCount() {
        count++;
        System.out.println("count = " + count);
    }

    // 定义一个线程类来调用 addCount() 方法
    private static class MyThread extends Thread {
        private SynchronizedThread synchronizedThread;

        public MyThread(SynchronizedThread synchronizedThread) {
            this.synchronizedThread = synchronizedThread;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronizedThread.addCount();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedThread synchronizedThread = new SynchronizedThread();
        MyThread thread1 = new MyThread(synchronizedThread);
        MyThread thread2 = new MyThread(synchronizedThread);
        thread1.start();
        thread2.start();
    }
}

2. Méthodes synchronisées

Après avoir marqué une méthode comme synchronisée, la méthode sera synchronisée et un seul thread pourra y entrer. Par exemple :

public synchronized void addCount() {
    count++;
    System.out.println("count = " + count);
}

3. Classe Lock

Lock est un autre mécanisme de synchronisation en Java. Il offre une synchronisation des threads plus flexible, facilitant ainsi le basculement entre plusieurs verrous. Lock implémente l'interface java.util.concurrent.locks.Lock et fournit les méthodes suivantes :

• lock() : Essayez d'obtenir le verrou si le verrou est déjà occupé, le thread attendra que le verrou soit obtenu.
• unlock() : Libérez le verrou.
• tryLock() : Essayez d'obtenir le verrou si le verrou est déjà occupé, il renverra immédiatement false.
• newCondition() : Renvoie l'instance de Condition liée à ce verrou. Avant d'appeler la méthode wait() de Condition, le thread doit obtenir le verrou du moniteur d'objet associé au verrou.

Exemple :

Lock lock = new ReentrantLock();

public void addCount() {
    lock.lock();
    try {
        count++;
        System.out.println("count = " + count);
    } finally {
        lock.unlock();
    }
}

Java Thread Pool

Le pool de threads en Java est un mécanisme de gestion et de réutilisation des threads. Le pool de threads peut mieux utiliser les performances du processeur, réduire la création et la destruction de threads et améliorer la vitesse de réponse du programme. En Java, les pools de threads peuvent être créés via la classe ThreadPoolExecutor. Vous pouvez spécifier des paramètres tels que la taille du pool de threads et la longueur de la file d'attente, et vous pouvez également effectuer diverses tâches.

Par exemple :

ExecutorService threadPool = Executors.newFixedThreadPool(10);
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        // 执行任务
    }
});

Résumé

La programmation multithread en Java est un moyen important d'améliorer la simultanéité et l'efficacité des programmes. En plus de présenter les deux façons de créer des multi-threads en Java (hériter de la classe Thread et implémenter l'interface Runnable), il introduit également diverses méthodes de synchronisation et pools de threads Java. Comprendre les concepts de base et la mise en œuvre de la programmation multithread est crucial pour développer des programmes efficaces et hautement simultanés.

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!