Comment implémenter la programmation simultanée en utilisant le multithreading en Java ?

Comment implémenter la programmation concurrente en utilisant le multi-threading en Java ?

Dans le développement des processeurs informatiques modernes, nous avons vu l'émergence de processeurs multicœurs, qui offrent plus de possibilités de programmation simultanée. En tant que langage de programmation largement utilisé, Java fournit une riche bibliothèque multithread pour aider les développeurs à réaliser une programmation simultanée efficace. Cet article explique comment implémenter la programmation simultanée à l'aide du multithreading en Java et fournit des exemples de code.

1. Deux façons de créer un thread

En Java, il existe deux façons de créer un thread : hériter de la classe Thread et implémenter l'interface Runnable.

Méthode 1 : hériter de la classe Thread

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

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

Méthode 2 : implémenter l'interface Runnable

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

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

2. Synchronisation et exclusion mutuelle

Lorsque plusieurs threads accèdent à des ressources partagées en même temps, une incohérence des données ou d'autres problèmes peuvent survenir. Afin d'éviter ces problèmes, nous devons assurer la synchronisation et l'exclusion mutuelle entre les threads. Java fournit le mot-clé synchronisé pour réaliser la synchronisation et l'exclusion mutuelle entre les threads.

class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                counter.increment();
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000000; i++) {
                counter.increment();
            }
        });

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        System.out.println("Count: " + counter.getCount());
    }
}

Dans le code ci-dessus, nous avons créé une classe de compteur thread-safe Counter, en utilisant le mot-clé synchronisé pour assurer le fonctionnement atomique des méthodes incrément() et getCount(). Dans la méthode main(), nous créons deux threads pour incrémenter la valeur du compteur et enfin afficher la valeur du compteur.

3. Communication entre les threads

Plusieurs threads peuvent avoir besoin de communiquer. Java fournit des méthodes telles que wait(), notify() et notifyAll() pour établir la communication entre les threads.

class Message {
    private String content;
    private boolean empty = true;

    public synchronized String read() {
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = true;
        notifyAll();
        return content;
    }

    public synchronized void write(String content) {
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = false;
        this.content = content;
        notifyAll();
    }
}

public class Main {
    public static void main(String[] args) {
        Message message = new Message();

        Thread producer = new Thread(() -> {
            String[] contents = {"Message 1", "Message 2", "Message 3"};
            for (String content : contents) {
                message.write(content);
            }
        });

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println("Message received: " + message.read());
            }
        });

        producer.start();
        consumer.start();
    }
}

Dans le code ci-dessus, nous avons créé une classe Message pour stocker les messages. La méthode read() attend lorsque le message est vide et ne revient que lorsqu'un nouveau message est écrit. La méthode write() attend que le message ne soit pas vide et continue d'écrire de nouveaux messages jusqu'à ce que le message soit lu.

4. Thread Pool

Dans les applications réelles, la création et la destruction de threads sont une opération très gourmande en ressources, et le pool de threads peut réutiliser les threads et contrôler le nombre de threads, améliorant ainsi l'utilisation des ressources. Java fournit la classe ThreadPoolExecutor pour implémenter un pool de threads.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                System.out.println("Task executed by " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

Dans le code ci-dessus, nous avons créé un pool de threads contenant 5 threads et soumis 10 tâches au pool de threads pour exécution. Enfin, nous devons appeler la méthode executor.shutdown() pour arrêter le pool de threads.

Résumé :

Cet article explique comment utiliser le multithreading en Java pour implémenter la programmation simultanée et fournit des exemples de code correspondants. En utilisant plusieurs threads et en effectuant la synchronisation, l'exclusion mutuelle et la communication entre les threads, nous pouvons réaliser une programmation simultanée efficace. Dans le même temps, l'utilisation du pool de threads peut également améliorer l'utilisation des ressources et les performances du programme. J'espère que cet article vous aidera à comprendre la programmation simultanée.

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!