Programmation multithread Java : création de threads, synchronisation et communication

Programmation multithread Java : création de threads, synchronisation et communication

En tant que langage de programmation orienté objet, Java prend en charge la programmation multithread et peut gérer des problèmes de concurrence multitâches complexes. En décomposant un programme en plusieurs threads d'exécution pour exécuter des tâches simultanément, la programmation multithread de Java peut améliorer considérablement les performances du programme.

En Java, un thread est un chemin d'exécution léger qui partage la mémoire et d'autres ressources avec d'autres threads. Chaque thread effectue ses propres tâches de manière indépendante, mais les threads peuvent coordonner et partager des ressources via la synchronisation et la communication.

Création de threads
Il existe deux manières de créer des threads en Java : hériter de la classe Thread et implémenter l'interface Runnable.

Héritez la méthode de classe Thread :

public class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread is running.");
    }
}

Implémentez la méthode d'interface Runnable :

public class MyRunnable implements Runnable{
    public void run(){
        System.out.println("MyRunnable is running.");
    }
}

La méthode de démarrage du thread est la suivante :

// 继承Thread类方式
Thread thread1 = new MyThread();
thread1.start();

// 实现Runnable接口方式
Thread thread2 = new Thread(new MyRunnable());
thread2.start();

Synchronisation des threads
Dans la programmation multi-thread Java, puisque l'ordre d'exécution entre les threads est imprévisible, Ainsi, si plusieurs threads accèdent aux ressources partagées en même temps, des problèmes de course aux données peuvent survenir, entraînant des résultats de programme incorrects.

Afin de garantir une coordination et un partage de données corrects entre les threads, des mécanismes de synchronisation et des verrous d'objet sont fournis en Java. Le mécanisme de synchronisation est implémenté via le mot-clé synchronisé et le mécanisme de verrouillage est implémenté via l'objet lock en Java.

Voici comment utiliser le mot-clé synchronisé :

public class MyCounter {
    private int count;

    public synchronized void increment() {
        count++;
    }
}

Dans le code ci-dessus, la méthode increment() est une méthode thread-safe, c'est-à-dire qu'un seul thread peut accéder à cette méthode à en même temps. increment()方法为线程安全方法，即在同一时刻只有一个线程能够访问该方法。

下面是lock对象的使用方式：

public class MyCounter {
    private int count;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

上述代码中，increment()方法同样是线程安全方法，为了保证线程安全，需要先通过lock()方法获得对象锁，然后执行完操作后再释放对象锁。

线程通信
通过线程同步机制可以保证线程安全，但是有些情况下需要线程间的协调和信息交换，这时就需要线程通信机制。线程通信机制包括wait()、notify()和notifyAll()三个方法。

wait()方法使当前线程等待，并将线程的状态设置为等待状态，直到另一个线程使用notify()方法通知或者wait()时间超时。

notify()方法则唤醒一个等待状态的线程，如果有多个线程在等待状态，只能随机选择其中的一个线程唤醒。

notifyAll()方法唤醒所有等待状态的线程，这样多个等待状态的线程就能够同时运行。

下面是线程通信的示例：

public class MyQueue {
    private Queue<String> queue = new LinkedList<>();

    public synchronized void put(String value) {
        queue.add(value);
        notify();
    }

    public synchronized String get() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();
        }
        return queue.remove();
    }
}

上述代码中，put()方法将元素添加到队列中，并使用notify()方法通知等待的线程；get()方法则等待队列中的元素，在元素可获得时使用notify()

Voici comment utiliser l'objet lock :

rrreee
Dans le code ci-dessus, la méthode increment() est également une méthode thread-safe. Afin de garantir la sécurité des threads, vous devez. passez d'abord lock(). La méthode code> obtient le verrou d'objet, puis libère le verrou d'objet après avoir terminé l'opération.

🎜Communication par thread🎜La sécurité des threads peut être assurée grâce au mécanisme de synchronisation des threads, mais dans certains cas, une coordination et un échange d'informations entre les threads sont nécessaires, auquel cas un mécanisme de communication par thread est nécessaire. Le mécanisme de communication des threads comprend trois méthodes : wait(), notify() et notifyAll(). La méthode 🎜🎜wait() fait attendre le thread actuel et définit le statut du thread sur l'état d'attente jusqu'à ce qu'un autre thread utilise la méthode notify() pour notifier ou que le délai wait() expire. La méthode 🎜🎜notify() réveille un thread en état d'attente. S'il y a plusieurs threads en état d'attente, un seul d'entre eux peut être sélectionné au hasard pour se réveiller. La méthode 🎜🎜notifyAll() réveille tous les threads d'état d'attente, afin que plusieurs threads d'état d'attente puissent s'exécuter en même temps. 🎜🎜Ce qui suit est un exemple de communication par thread : 🎜rrreee🎜Dans le code ci-dessus, la méthode put() ajoute des éléments à la file d'attente et utilise notify() pour notifier le thread en attente ; la méthode get() attend les éléments dans la file d'attente et utilise la méthode notify() pour notifier le thread en attente lorsque l'élément est disponible. . 🎜🎜Conclusion🎜La programmation multithread en Java est une tâche complexe qui nécessite une conception et une mise en œuvre minutieuses pour garantir l'exactitude et les performances du programme. Comprendre les mécanismes de création, de synchronisation et de communication des threads peut vous aider à maîtriser les points essentiels de la programmation multithread en Java, améliorant ainsi la qualité et les performances de votre programme. 🎜

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!