Comment utiliser les threads en Java

Comment utiliser Thread en Java, exemples de code spécifiques

1. Introduction
   En Java, la programmation multithread est un moyen puissant d'améliorer l'efficacité et la concurrence du programme. La classe Thread est la classe principale de Java utilisée pour créer et gérer des threads. Cet article présentera en détail l’utilisation de la classe Thread et fournira quelques exemples de code spécifiques.
2. Créer un fil
   Les objets Thread peuvent être créés de deux manières : en héritant de la classe Thread et en implémentant l'interface Runnable. L'héritage de la classe Thread est un moyen simple, mais comme Java ne prend en charge que l'héritage unique, cette méthode limitera l'évolutivité du code. L'implémentation de l'interface Runnable peut éviter ce problème, car Java prend en charge l'implémentation de plusieurs interfaces.

Ce qui suit est un exemple de code d'utilisation de deux méthodes pour créer un thread :

// 继承Thread类
class MyThread extends Thread {
    public void run(){
        // 线程执行的代码
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    public void run(){
        // 线程执行的代码
    }
}

// 创建线程并启动
public static void main(String[] args){
    // 创建继承Thread类的线程
    MyThread thread1 = new MyThread();
    thread1.start();

    // 创建实现Runnable接口的线程
    MyRunnable runnable = new MyRunnable();
    Thread thread2 = new Thread(runnable);
    thread2.start();
}

Dans le code ci-dessus, le thread créé en héritant de la classe Thread appelle directement la méthode start pour démarrer le thread, tandis que le thread créé en implémentant l'interface Runnable Le thread doit d'abord créer un objet Thread, transmettre l'objet qui implémente l'interface Runnable en tant que paramètre au constructeur Thread, puis appeler la méthode start de l'objet Thread pour démarrer le thread.

3. Cycle de vie du thread
   Un thread passera par plusieurs états après sa création, et ces états sont appelés le cycle de vie du thread. Les états courants du thread sont : Nouveau, Exécutable, En cours d’exécution, Bloqué et Terminé.

Ce qui suit est un exemple simple montrant le cycle de vie d'un thread :

class MyThread extends Thread {
    public void run(){
        System.out.println("线程执行中");

        try {
            Thread.sleep(1000); // 线程等待1秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("线程执行结束");
    }
}

public static void main(String[] args){
    MyThread thread = new MyThread();
    System.out.println("线程状态：" + thread.getState()); // 输出线程状态为New
    thread.start();
    System.out.println("线程状态：" + thread.getState()); // 输出线程状态为Runnable
    // 等待线程执行结束
    try {
        thread.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("线程状态：" + thread.getState()); // 输出线程状态为Terminated
}

Dans le code ci-dessus, après la création et le démarrage d'un nouveau thread, le statut du thread est d'abord affiché comme étant Nouveau, puis le statut est exécutable. Après avoir appelé la méthode thread.join() et attendu la fin de l'exécution du thread, l'état de sortie final est Terminé.

4. Synchronisation des threads et exclusion mutuelle
   Dans la programmation multithread, la synchronisation des threads et l'exclusion mutuelle sont des concepts très importants. Lorsque plusieurs threads accèdent à des ressources partagées en même temps, afin d'éviter les conditions de concurrence et les incohérences des données, des mesures de synchronisation appropriées doivent être prises.

Java fournit des mécanismes tels que le mot-clé synchronisé et l'interface Lock pour réaliser la synchronisation des threads et l'exclusion mutuelle. Voici un exemple d'utilisation du mot-clé synchronisé pour la synchronisation des threads :

class Counter {
    private int count = 0;

    // 线程安全的方法
    public synchronized void increment(){
        count++;
    }

    public int getCount(){
        return count;
    }
}

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

    Runnable runnable = () -> {
        for(int i=0; i<10000; i++){
            counter.increment();
        }
    };

    Thread thread1 = new Thread(runnable);
    Thread thread2 = new Thread(runnable);

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

    try {
        thread1.join();
        thread2.join();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("计数器的值：" + counter.getCount()); // 输出：20000
}

Dans l'exemple de code ci-dessus, une classe Counter thread-safe est définie, dans laquelle la méthode d'incrémentation utilise le mot-clé synchronisé pour synchroniser les données partagées. Deux threads ont appelé l'objet Counter en même temps. Chaque thread a effectué 10 000 opérations d'incrémentation sur le nombre et a finalement généré le résultat correct de 20 000.

5. Interruption des threads
   Java fournit un mécanisme pour interrompre un thread en cours d'exécution. Vous pouvez appeler la méthode d'interruption de la classe Thread pour envoyer un signal d'interruption. Le thread interrompu peut déterminer si un signal d'interruption a été reçu en appelant la méthode isInterrupted, puis prendre les mesures appropriées si nécessaire.

Voici un exemple de code qui montre comment interrompre un thread :

class MyThread extends Thread {
    public void run(){
        while(!isInterrupted()){
            System.out.println("线程运行中");
            try {
                Thread.sleep(1000); // 线程等待1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
        }
        System.out.println("线程中断");
    }
}

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

    try {
        Thread.sleep(5000); // 主线程等待5秒
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    thread.interrupt(); // 中断线程
}

Dans le code ci-dessus, après la création et le démarrage d'un nouveau thread, le thread principal attend 5 secondes puis interrompt le thread enfant.

Résumé :
Cet article présente comment utiliser la classe Thread en Java et fournit quelques exemples de code spécifiques. Vous pouvez créer un thread en héritant de la classe Thread ou en implémentant l'interface Runnable, et démarrer le thread en appelant la méthode start. Comprendre le cycle de vie des threads et les concepts de synchronisation des threads et d'exclusion mutuelle est très important pour écrire des programmes multithread robustes. Dans le même temps, comprendre comment interrompre les threads est également un point de connaissance important dans la programmation multithread. La maîtrise de ces contenus peut aider les développeurs à utiliser la programmation multithread pour améliorer l'efficacité et la simultanéité des programmes.

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!