Comment utiliser la fonction Thread en Java pour les opérations de thread

La fonction Thread en Java est une classe fournie par Java pour créer et contrôler des threads. Les threads peuvent implémenter des opérations simultanées dans le programme et améliorer l'efficacité de l'exécution du programme. La fonction Thread fournit de nombreuses méthodes pour faciliter les opérations de thread. Cet article explique comment utiliser la fonction Thread en Java pour les opérations de thread.

1. Création de threads

Il existe deux façons de créer des threads en Java : hériter de la classe Thread et implémenter l'interface Runnable. L'héritage de la classe Thread est une approche plus simple, mais elle est limitée par le modèle d'héritage unique de Java. L'implémentation de l'interface Runnable est une approche plus flexible qui évite ce problème.

Le code qui hérite de la classe Thread est le suivant :

class MyThread extends Thread {
    public void run() {
        // 线程运行的代码
    }
}

// 创建线程
MyThread thread = new MyThread();

// 启动线程
thread.start();

Le code qui implémente l'interface Runnable est le suivant :

class MyRunnable implements Runnable {
    public void run() {
        // 线程运行的代码
    }
}

// 创建线程
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);

// 启动线程
thread.start();

2. Contrôle des threads

La fonction Thread en Java fournit quelques méthodes pour contrôler facilement les threads. Voici quelques méthodes couramment utilisées.

1) méthode de mise en veille : laissez le fil dormir pendant un certain temps, l'unité est la milliseconde.

try {
    Thread.sleep(1000); // 线程睡眠1秒钟
} catch (InterruptedException e) {
    e.printStackTrace();
}

2) Méthode Yield : abandonnez les droits d'exécution du processeur du thread actuel et donnez aux autres threads une chance de s'exécuter.

Thread.yield();

3) méthode join : attendez qu'un autre thread termine son exécution avant de l'exécuter.

try {
    thread.join(); // 等待thread线程执行完毕后再执行
} catch (InterruptedException e) {
    e.printStackTrace();
}

4) méthode d'interruption : interrompre le fil de discussion.

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

3. Synchronisation des threads

La synchronisation des threads signifie que dans un environnement multi-thread, puisque l'exécution de plusieurs threads est incertaine, deux ou plusieurs threads peuvent modifier la même ressource partagée en même temps, ce qui entraîne des données incohérentes. Java fournit le mot clé synchronisé et le mécanisme de verrouillage pour résoudre ce problème.

class MyThread implements Runnable {
    private Integer count = 0;

    public synchronized void run() {
        for (int i = 0; i < 10; i++) {
            count++; // 对共享资源进行操作
            System.out.println(Thread.currentThread().getName() + " count: " + count);
            Thread.yield();
        }
    }
}

// 创建两个线程
MyThread runnable = new MyThread();
Thread t1 = new Thread(runnable, "Thread1");
Thread t2 = new Thread(runnable, "Thread2");

// 启动两个线程
t1.start();
t2.start();

Dans le code ci-dessus, nous utilisons le mot-clé synchronisé pour garantir que l'accès de plusieurs threads à la variable count s'exclut mutuellement.

4. Collaboration entre threads

La collaboration entre threads fait référence à la collaboration entre plusieurs threads, leur permettant de s'exécuter dans un certain ordre. La fonction Thread en Java fournit des méthodes d'attente et de notification pour réaliser une coopération de thread.

class MyThread implements Runnable {
    private boolean running = true;

    public synchronized void run() {
        while (running) {
            try {
                System.out.println(Thread.currentThread().getName() + " is running");
                wait(); // 等待其他线程唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " is stopped");
    }

    public synchronized void stop() {
        running = false;
        notify(); // 唤醒其他线程
    }
}

// 创建线程
MyThread runnable = new MyThread();
Thread thread = new Thread(runnable);

// 开始线程
thread.start();

// 停止线程
runnable.stop();

Dans le code ci-dessus, nous utilisons la méthode wait pour laisser le thread attendre que les autres threads se réveillent, et utilisons la méthode notify pour réveiller les autres threads.

5. Thread pool

Thread pool est une méthode courante de gestion de threads, qui permet la réutilisation des threads et améliore l'efficacité du programme. La fonction Thread en Java fournit la classe ThreadPoolExecutor pour implémenter un pool de threads.

class MyTask implements Runnable {
    private Integer id;

    public MyTask(Integer id) {
        this.id = id;
    }

    public void run() {
        System.out.println("Task " + id + " is running");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任务
for (int i = 0; i < 10; i++) {
    executor.submit(new MyTask(i));
}

// 关闭线程池
executor.shutdown();

Dans le code ci-dessus, nous créons un pool de threads en appelant la méthode newFixedThreadPool des Executors, puis soumettons la tâche et enfin fermons le pool de threads.

Résumé

La fonction Thread en Java fournit de nombreuses méthodes pour des opérations de thread pratiques. Dans la programmation réelle, nous devons choisir différents modèles de threads en fonction de nos propres besoins, et en même temps, nous devons prêter attention à des problèmes tels que la synchronisation des threads et la collaboration des threads pour garantir l'exactitude et l'efficacité du fonctionnement du 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!