Création et démarrage du multi-threading java

Les threads en Java sont généralement créés sous trois formes de base :

1 Héritez de la classe Thread et remplacez la méthode run() de cette classe

Héritez la classe Thread et remplacez la méthode run() de cette classe

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0 ;i < 50;i++) {
            System.out.println(Thread.currentThread().getName() + "：" + i);
        }
    }
    public static void main(String[] args) {
        for (int i = 0;i<50;i++) {
            //调用Thread类的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 10) {
                new MyThread().start();
                new MyThread().start(); 
            }
        }
    }
}

Résultat de l'exécution :

...
main 48
main 49
Thread-0：0
Thread-0：1
Thread-0：2
Thread-0：3
Thread-0：4
Thread-1：0
...

Comme le montre le résultat :

1. Il y a trois threads : main, Thread-0, Thread-1 ;

2. La valeur de la variable membre i générée par les deux threads Thread-0 et Thread-1 n'est pas. continue (je suis ici des variables d'instance plutôt que des variables locales). Parce que : lors de l'implémentation du multi-threading en héritant de la classe Thread, la création de chaque thread nécessite la création d'un objet de sous-classe différent, ce qui fait que les deux threads Thread-0 et Thread-1 ne partagent pas la variable membre i

3. L'exécution du thread est préemptive, et il n'est pas dit que Thread-0 ou Thread-1 occupe toujours le CPU (cela est également lié à la priorité du thread. Ici, Thread-0 et Thread-1 ont le même priorité de fil de discussion. Les connaissances sur la priorité de fil de discussion ne sont pas disponibles ici. Développer)

(Recommandation vidéo d'apprentissage :

Tutoriel vidéo Java)

2. Créez un fil de discussion. classe en implémentant l'interface Runnable

Définir une classe qui implémente l'interface Runnable ; créer un objet instance obj de la classe ; passer obj en tant que paramètre constructeur à l'objet instance de la classe Thread. véritable objet de fil.

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0 ;i < 50 ;i++) {
            System.out.println(Thread.currentThread().getName()+"：" +i);
        }
    }

    public static void main(String[] args) {
       for (int i = 0;i < 50;i++) {
            System.out.println(Thread.currentThread().getName() + "：" +i);
            if (i == 10) {
                MyRunnable myRunnable = new MyRunnable();
                new Thread(myRunnable).start();
                new Thread(myRunnable).start();
            }
        }
        //java8 labdam方式
         new Thread(() -> {
            System.out.println(Thread.currentThread().getName());
        },"线程3").start();
    }
}

Résultats d'exécution :

...
main：46
main：47
main：48
main：49
Thread-0：28
Thread-0：29
Thread-0：30
Thread-1：30
...

1. La variable membre i générée par le thread 1 et le thread 2 est continue, ce qui signifie qu'en créant des threads de cette manière, plusieurs threads peuvent partager des classes de thread. Variables d'instance, car plusieurs threads utilisent ici la même variable d'instance cible. Cependant, lorsque vous exécutez le code ci-dessus, vous constaterez que les résultats ne sont en réalité pas continus. En effet, lorsque plusieurs threads accèdent à la même ressource, si la ressource n'est pas verrouillée, des problèmes de sécurité des threads se produiront

 ; 2. Java8 peut utiliser la méthode lambda pour créer des multi-threads.

3. Créez des threads via les interfaces Callable et Future

Créez une classe d'implémentation d'interface Callable et implémentez la méthode call(), qui servira de corps d'exécution du thread, et la méthode a une valeur de retour, puis créez une instance de la classe d'implémentation Callable ; utilisez la classe FutureTask pour envelopper l'objet Callable, qui encapsule la valeur de retour de la méthode call() de l'objet Callable ; en tant que cible de l'objet Thread pour créer et démarrer un nouveau Thread ; appelez la méthode get() de l'objet FutureTask pour obtenir la valeur de retour une fois l'exécution du thread enfant terminée. Le type de valeur de retour de la méthode

public class MyCallable implements Callable<Integer> {
    private int i = 0;
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建MyCallable对象
        Callable<Integer> myCallable = new MyCallable();
        //使用FutureTask来包装MyCallable对象
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable);
        for (int i = 0;i<50;i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            if (i == 30) {
                Thread thread = new Thread(ft);
                thread.start();
            }
        }
        System.out.println("主线程for循环执行完毕..");
        Integer integer = ft.get();
        System.out.println("sum = "+ integer);
    }
}

call() est cohérent avec le type dans <> lors de la création de l'objet FutureTask.

Tutoriels associés recommandés :

Démarrage rapide Java

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!