Méthode de création de threads de programmation simultanée Java :

1. Threads et processus

Un processus est une activité de code en cours d'exécution sur une collection de données. C'est l'unité de base de l'allocation et de la planification des ressources dans le système. , qui est la planification et l'allocation du processeur. L'unité de base d'un processus est que plusieurs threads d'un processus partagent les ressources du processus.

Trois caractéristiques des processus :

• Dynamique : Un processus est un programme en cours d'exécution qui occupe dynamiquement des ressources telles que la mémoire, le processeur et le réseau.

• Indépendance : Les processus sont indépendants les uns des autres et possèdent leurs propres zones de mémoire indépendantes.

• Concurrence : Si le processeur est un seul cœur, il n'y a en fait qu'un seul processus exécuté dans la mémoire en même temps. Le processeur interrogera et basculera en temps partagé pour servir chaque processus à tour de rôle. La vitesse de commutation étant très rapide, cela nous donne le sentiment que ces processus s'exécutent en même temps.

2. Création et exécution de threads

Nous avons trois façons de créer des threads dans un processus :

• Méthode 1 : Hériter de la classe Thread

• 1. la classe Thread.

• 2. Remplacez la méthode run()

• 3. Créez un nouvel objet thread.

• 4. Appelez la méthode start() de l'objet thread pour démarrer le thread.

public class ThreadDemo {
    // 启动后的ThreadDemo当成一个进程。
    // main方法是由主线程执行的，理解成main方法就是一个主线程
    public static void main(String[] args) {
        // 3.创建一个线程对象
        Thread t = new MyThread();
        // 4.调用线程对象的start()方法启动线程,最终还是执行run()方法！
        t.start();

        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("main线程输出："+i);
        }
    }
}

// 1.定义一个线程类继承Thread类。
class MyThread extends Thread{
    // 2.重写run()方法
    @Override
    public void run() {
        // 线程的执行方法。
        for(int i = 0 ; i < 100 ; i++ ){
            System.out.println("子线程输出："+i);
        }
    }
}

Avantages : Le codage est simple, il suffit de l'utiliser directement pour obtenir le thread actuel dans la méthode run(), sans utiliser la méthode Thread.currentThread(). Inconvénients : la classe thread a hérité de la classe Thread et ne peut pas hériter d'autres classes, et les fonctions ne peuvent pas être étendues par héritage (limitations de l'héritage unique). De plus, les tâches et les codes ne sont pas séparés. Lorsque plusieurs threads exécutent la même tâche, plusieurs codes de tâche sont requis.

Résumé :

• La classe thread est une classe qui hérite de Thread.

• Pour démarrer un fil de discussion, vous devez appeler la méthode start().

• Le multithreading consiste à anticiper simultanément l'exécution du processeur, de sorte que le caractère aléatoire de la concurrence se produira pendant le processus d'exécution

Deuxième méthode : La manière d'implémenter l'interface Runnable.

• 1. Créez une classe de tâches de thread pour implémenter l'interface Runnable.

• 2. Remplacez la méthode run()

• 3. Créez un objet tâche de thread.

• 4. Emballez l'objet tâche de thread dans un objet thread

• 5. Appelez la méthode start() de l'objet thread pour démarrer le thread.

public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的)
        Runnable target = new MyRunnable();
        // 4.把线程任务对象包装成线程对象.且可以指定线程名称
        // Thread t = new Thread(target);
        Thread t = new Thread(target,"1号线程");
        // 5.调用线程对象的start()方法启动线程
        t.start();

        Thread t2 = new Thread(target);
        // 调用线程对象的start()方法启动线程
        t2.start();

        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

// 1.创建一个线程任务类实现Runnable接口。
class MyRunnable implements Runnable{
    // 2.重写run()方法
    @Override
    public void run() {
        for(int i = 0 ; i < 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+"==>"+i);
        }
    }
}

Avantages :

La classe de tâches de thread implémente uniquement l'interface Runnable, peut continuer à hériter d'autres classes et peut continuer à implémenter d'autres interfaces (en évitant les limitations de l'héritage unique). Le même objet de tâche de thread peut être regroupé en plusieurs objets de thread, adaptés à plusieurs threads pour partager la même ressource. Pour réaliser des opérations de découplage, le code de tâche de thread peut être partagé par plusieurs threads, et le code de tâche de thread et les threads sont indépendants.

Méthode 3 : Implémentez l'interface Callable

• 1 Définissez une classe de tâches de thread pour implémenter l'interface Callable et déclarez le type de résultat de l'exécution du thread.

• 2. Réécrivez la méthode d'appel de la classe de tâche thread Cette méthode peut renvoyer directement le résultat de l'exécution.

• 3. Créez un objet de tâche de thread appelable.

• 4. Emballez l'objet de tâche de thread Callable dans un objet FutureTask.

• 5. Emballez l'objet FutureTask dans un objet thread.

• 6. Appelez la méthode start() du fil pour démarrer le fil.

public class ThreadDemo {
    public static void main(String[] args) {
        // 3.创建一个Callable的线程任务对象
        Callable call = new MyCallable();
        // 4.把Callable任务对象包装成一个未来任务对象
        //      -- public FutureTask(Callable<V> callable)
        // 未来任务对象是啥，有啥用？
        //      -- 未来任务对象其实就是一个Runnable对象:这样就可以被包装成线程对象！
        //      -- 未来任务对象可以在线程执行完毕之后去得到线程执行的结果。
        FutureTask<String> task = new FutureTask<>(call);
        // 5.把未来任务对象包装成线程对象
        Thread t = new Thread(task);
        // 6.启动线程对象
        t.start();

        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
        }

        // 在最后去获取线程执行的结果,如果线程没有结果，让出CPU等线程执行完再来取结果
        try {
            String rs = task.get(); // 获取call方法返回的结果（正常/异常结果）
            System.out.println(rs);
        }  catch (Exception e) {
            e.printStackTrace();
        }

    }
}

// 1.创建一个线程任务类实现Callable接口，申明线程返回的结果类型
class MyCallable implements Callable<String>{
    // 2.重写线程任务类的call方法！
    @Override
    public String call() throws Exception {
        // 需求：计算1-10的和返回
        int sum = 0 ;
        for(int i = 1 ; i <= 10 ; i++ ){
            System.out.println(Thread.currentThread().getName()+" => " + i);
            sum+=i;
        }
        return Thread.currentThread().getName()+"执行的结果是："+sum;
    }
}

Avantages : La classe de tâches thread implémente uniquement l'interface Callable et peut continuer à hériter d'autres classes et à implémenter d'autres interfaces (en évitant les limitations de l'héritage unique). Le même objet de tâche de thread peut être regroupé en plusieurs objets de thread, adaptés à plusieurs threads pour partager la même ressource. Pour réaliser des opérations de découplage, le code de tâche de thread peut être partagé par plusieurs threads, et le code de tâche de thread et les threads sont indépendants. Le plus important est de pouvoir obtenir directement les résultats de l'exécution du thread.

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!