Comment utiliser la programmation simultanée multithread dans Java 7

Comment utiliser la programmation simultanée multithread dans Java 7

Dans les systèmes informatiques modernes, la programmation multithread est devenue un moyen courant de tirer pleinement parti des processeurs multicœurs et du calcul parallèle. En tant que langage de programmation couramment utilisé, Java prend en charge le multithreading, permettant aux développeurs d'utiliser le multithreading pour implémenter une programmation simultanée. Cet article explique comment utiliser le multithreading pour implémenter la programmation simultanée dans Java 7, avec des exemples de code.

1. Création de threads
   En Java, vous pouvez créer un thread en héritant de la classe Thread ou en implémentant l'interface Runnable. Voici un exemple de code pour créer un fil de discussion en héritant de la classe Thread :

   public class MyThread extends Thread {
    public void run() {
        // 线程的执行逻辑
    }
   }

   L'exemple de code pour créer un fil de discussion en implémentant l'interface Runnable est le suivant :

   public class MyRunnable implements Runnable {
    public void run() {
        // 线程的执行逻辑
    }
   }

2. Démarrer un fil de discussion
   Après avoir créé un fil de discussion, vous vous devez appeler la méthode start() pour démarrer le thread. Voici un exemple de code pour démarrer un fil de discussion :

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

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

3. Synchronisation des threads
   Dans la programmation multithread, si plusieurs threads lisent et écrivent des données partagées en même temps, des incohérences de données ou des conflits peuvent survenir. Afin d'éviter ce problème, vous pouvez utiliser un mécanisme de synchronisation pour garantir la sécurité des threads. Java fournit le mot-clé synchronisé et la classe Lock pour implémenter la synchronisation des threads. Voici un exemple de code qui utilise le mot-clé synchronisé pour réaliser la synchronisation des threads :

   public class Counter {
    private int count = 0;
   
    public synchronized void increment() {
        count++;
    }
   }

   public static void main(String[] args) {
    Counter counter = new Counter();
   
    Thread thread1 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    });
   
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    });
   
    thread1.start();
    thread2.start();
   
    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
   
    System.out.println(counter.getCount());
   }

4. Communication inter-thread
   Dans la programmation multithread, nous devons parfois communiquer entre les threads, par exemple, un thread attend qu'un autre thread se termine une certaine tâche. Continuer l’exécution. Java fournit les méthodes wait(), notify() et notifyAll() pour implémenter la communication entre les threads. Ce qui suit est un exemple de code qui implémente la communication inter-thread via les méthodes wait() et notify() :

   public class Message {
    private String message;
    private boolean empty = true;
   
    public synchronized String read() {
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = true;
        notifyAll();
        return message;
    }
   
    public synchronized void write(String message) {
        while (!empty) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        empty = false;
        this.message = message;
        notifyAll();
    }
   }

   public static void main(String[] args) {
    Message message = new Message();
   
    Thread thread1 = new Thread(() -> {
        String[] messages = { "Message 1", "Message 2", "Message 3" };
        for (String msg : messages) {
            message.write(msg);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
   
    Thread thread2 = new Thread(() -> {
        for (int i = 0; i < 3; i++) {
            String msg = message.read();
            System.out.println(msg);
        }
    });
   
    thread1.start();
    thread2.start();
   
    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
   }

   Ce qui précède est le processus de base et un exemple de code pour utiliser le multithreading pour implémenter la programmation simultanée dans Java 7. En utilisant rationnellement le multi-threading, vous pouvez utiliser pleinement les ressources informatiques et améliorer les performances du programme et la vitesse de réponse. Cependant, dans la programmation multithread, vous devez également faire attention à l'utilisation correcte des mécanismes de sécurité des threads et de synchronisation pour éviter des problèmes tels que l'incohérence des données et les conditions de concurrence.

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!