Implémentation du multithreading en Java

La première méthode consiste à définir une sous-classe de la classe Thread :

//第一种方法
public class MyThread extends Thread {
    @Override
    public void run() {
        String name = getName(); // 获取线程名称
        System.out.println(name); // 输出 Thread-0
    }
}

//第二种方法
public class MyThread extends Thread {
    @Override
    public void run() {
        Thread t = Thread.currentThread(); // 获取当前线程
        System.out.println(t); 	// 下面调用后输出 Thread[Thread-0,5,main]
        System.out.println(t.getName());// 输出 Thread-0
    }
}

Recommandation vidéo liée à Java : apprentissage en ligne Java

Activer le multi-threading :

public class demo1Test {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();// 会运行MyThread的run（）方法
   }
}

La deuxième façon consiste à implémenter l'interface Runnable :

Étapes d'implémentation :

1. Créez une classe d'implémentation de l'interface Runnable

2. Réécrivez la méthode run de l'interface Runnable dans la classe d'implémentation et définissez la tâche de thread

3. Créez un objet de classe d'implémentation du Interface Runnable

4. Créez un objet de classe Thread et transmettez l'objet de classe d'implémentation de l'interface Runnable dans la méthode de construction

5. Appelez la méthode start dans la classe Thread pour démarrer un nouveau thread. pour exécuter la méthode run

public class Runnableimpl implements Runnable {//1.创建一个Runnable 接口的实现类
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {// 2.在实现类中重写Runnable接口的run方法，设置线程任务
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

public class demo2Test {
    public static void main(String[] args) {
        Runnable run = new Runnableimpl();//3.创建一个Runnable接口的实现类对象
        Thread t = new Thread(run); //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        t.start();//5.调用Thread类中的start方法，开启新的线程执行run方法
        for (int i = 1; i <= 20; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }	// Thread-0和main开始多线程抢夺cpu
    }
}

Avantages de l'implémentation de l'interface Runnable pour créer des multi-threads :

Éviter les limitations de l'héritage unique : <🎜. >

Une classe ne peut hériter que d'une seule classe. Une fois qu'une classe hérite de Thread, elle ne peut pas hériter d'autres classes

implémente l'interface Runnable, et peut également hériter d'autres classes et implémenter d'autres interfaces.

2. Améliorer l'évolutivité du programme et réduire le couplage du programme

La façon d'implémenter l'interface Runnable consiste à séparer les tâches de configuration des threads et les tâches de démarrage des threads.

Dans la classe d'implémentation, remplacez la méthode run() pour définir les tâches du thread.

Créez un objet de classe Thread et appelez la méthode start() pour démarrer un nouveau fil

méthode sleep() pour mettre la méthode en veille

public class sleepTest {
    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
        //使用Thread类的sleep方法，让方法睡眠1秒钟
            try {
                Thread.sleep(1000);//传入的是毫秒值
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
}

java Articles et tutoriels connexes recommandés :

Démarrage rapide avec 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!