Comment créer du multithreading en Java ? (détaillé)

Le contenu de cet article explique comment créer du multi-threading en Java ? (Détails), il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Qu'est-ce qu'un thread :

Un thread est une entité dans le processus et constitue l'unité de base qui est planifiée et distribuée indépendamment par le système. pas posséder de ressources système, seulement C'est une ressource indispensable pendant le fonctionnement, mais il peut partager toutes les ressources possédées par le processus avec d'autres threads appartenant au même processus

En apparence, il est multi- threading, mais en fait, le CPU se relaye pour s'exécuter rapidement

Multi-threading (parallèle et concurrent)

1. Parallèle : deux tâches sont effectuées en même temps, c'est-à-dire que pendant l'exécution de la tâche A, la tâche B s'exécute également (nécessite plusieurs cœurs)

2. Concurrence : les deux tâches doivent s'exécuter et le processeur ne peut accepter qu'une seule tâche, donc les deux tâches doivent être exécutées tour à tour. Étant donné que l'intervalle de temps est très court, les gens ont l'impression que les deux tâches sont en cours d'exécution

Multi-threading (le principe de l'exécution d'un programme Java)

La commande Java va démarrez la jvm, ce qui équivaut à démarrer une application (un processus). Le processus démarrera automatiquement le "thread principal". Le thread principal appelle la méthode principale

Est-il monothread pour démarrer la jvm ?

Non, il est multithread. Au moins le thread de garbage collection et le thread principal seront démarrés

Cela peut être vérifié par le code suivant Le thread principal et le thread de garbage collection sont en compétition pour les ressources de chacun

public class TestThread {

    public static void main(String[] args) {
        //4.创建Thread的子类对象
        MyThread myThread = new MyThread();

        //5.启动线程，注意这里使用的是start而不是run方法
        myThread.start();

        for (int i = 0; i < 10000; i ++) {
            System.out.println("This is main thread");
        }
    }


}

//1.继承Thread
class MyThread extends  Thread{

    //2.重写run方法
    @Override
    public void run() {
        super.run();
        //3.线程方法中要执行的代码，可以根据自己的需求填写
        for(int i = 0 ; i < 10000 ; i ++ ) {
            System.out.println("This is MyThread thread ");
        }
    }
}

Comment créer plusieurs threads en Java

(1) Hériter de la classe Thread et appeler la méthode start

Thread implémente l'interface Runnable

Pour implémenter le multi-threading, vous doit devenir une sous-classe de thread et remplacer la méthode run. Notez que lors du démarrage d’un thread, ce n’est pas la méthode run mais la méthode start qui est appelée. Si la méthode run est appelée, cela équivaut à une méthode ordinaire qui n'ouvre pas le fil

public class Thread implements Runnable

public class TestThread {

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        //注意这里使用的是start而不是run方法
        myThread.start();

        for (int i = 0; i < 10000; i ++) {
            System.out.println("This is main thread");
        }
    }
}
class MyThread extends  Thread{
    @Override
    public void run() {
        super.run();

        for(int i = 0 ; i < 10000 ; i ++ ) {
            System.out.println("This is MyThread thread ");
        }
    }
}

(2) Implémenter l'interface exécutable et réécrire la méthode run

Il n'y en a qu'une dans Runnable Method run(), et la méthode de démarrage du thread existe dans Thread,

puis quand on démarre enfin le thread, il faut démarrer le thread via l'objet sous-classe de Thread

public class TestRunnable {

    public static void main(String[] args) {
        //4.创建Thread的子类对象
        Runnable myRunnable = new MyRunnable();

        //5.启动线程,创建Thread并把runnable的子类作为构造参数
        new Thread(myRunnable).start();

        for (int i = 0; i < 10000; i ++) {
            System.out.println("This is main thread");
        }
    }

}
//1.实现runnable接口
class MyRunnable implements Runnable {

    //2.重写run方法
    @Override
    public void run() {
        //3.线程方法中要执行的代码，可以根据自己的需求填写
        for(int i = 0 ; i < 10000 ; i ++ ) {
            System.out.println("This is MyRunnable thread ");
        }
    }
}

implémenter l'interface Callable

Pour implémenter les threads, en plus d'hériter du thread et de l'exécutable, vous pouvez également implémenter l'interface Callable. L'interface Callable fournit une méthode call() qui peut être utilisée comme corps d'exécution de thread, qui a la même fonction que run(). Mais la méthode call() a plus de valeurs de retour que la méthode run(), et la méthode call() peut déclarer l'exception levée. Alors, comment démarrer le thread Callable ? Étant donné que l'interface Callable n'est pas une sous-interface de l'interface Runnable, l'objet Callable ne peut pas être utilisé comme paramètre de construction du Thread. Java fournit une autre interface, l'interface RunnableFuture, qui implémente Runnable, Future

1. implémente l'interface

   Callable

2. Écrivez le

   call méthode, qui est équivalente à la méthode run dans le thread. La différence est que la méthode d'appel permet aux valeurs de retour

3. de transmettre l'objet de classe d'implémentation Callable en tant que paramètre de construction à FutureTask pour créer un objet FutureTask.

4. Passez l'objet FutureTask dans Thread en tant que paramètre de construction et démarrez le thread

public class CallableDemo {

    public static void main(String[] args) {
        //3.把Callable实现类对象作为构造参数传入FutureTask创建FutureTask对象。
        FutureTask<UUID> futureTask = new FutureTask<UUID>(new MyCallable());
        //4.把FutureTask对象作为构造参数传入Thread，并开启线程
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1. 实现**Callable**接口
class MyCallable implements Callable<UUID> {

    //2.重写**call**方法，相当于thread中的run方法。不同的是call方法允许有返回值
    @Override
    public UUID call() throws Exception {
        //生成随机数
        return UUID.randomUUID();
    }
}

Hériter Thread pour réaliser la différence entre Runnable et Callable

À partir de l'implémentation du code source

Hériter le fil

La sous-classe réécrit la méthode run() dans Thread, appelle la méthode start() et le jvm appellera automatiquement l'exécution de la sous-classe ()

Implement Runnable

new Thread(myRunnable) Entrez la référence de runnable dans le constructeur de Thread, puis transmettez-la à la variable membre cible du thread. Dans la méthode Thread run(), on juge que si la cible n'est pas vide, la méthode run de la sous-classe est appelée

    public void run() {
    if (this.target != null) {
        this.target.run();
    }

implémente l'interface Callable

implémente l'interface Callable et réécrit la méthode Call(). Et peut fournir une valeur de retour au thread ou lever une exception. Enfin, il est transmis à la variable membre target de Thread via la classe d'implémentation FutureTask de la sous-interface RunnableFuture.

En termes d'utilisation et d'expansion

Hériter le fil

1. Avantages : Appeler directement la méthode start() dans le fil, très simple

2. Inconvénients : Java ne prend en charge que l'héritage unique. Si une sous-classe hérite du thread, elle ne peut pas hériter d'autres classes

Implement Runnable

1. Avantages : Java peut implémenter plusieurs

2. Inconvénients : L'écriture du code est compliquée et start() ne peut pas être appelé directement

pour implémenter Callable

1. Avantages : Java peut être implémenté de plusieurs manières, peut lever des exceptions et peut avoir des valeurs de retour

2. Inconvénients : l'écriture de code est compliqué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!