Implementierung von Multithreading in Java

Die erste Möglichkeit besteht darin, eine Unterklasse der Thread-Klasse zu definieren:

//第一种方法
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
    }
}

Java-bezogene Videoempfehlung: Java-Online-Lernen

Multithreading aktivieren:

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

Die zweite Möglichkeit besteht darin, die Runnable-Schnittstelle zu implementieren:

Implementierungsschritte:

1. Erstellen Sie eine Implementierungsklasse der Runnable-Schnittstelle

2. Schreiben Sie die Ausführungsmethode der Runnable-Schnittstelle in der Implementierungsklasse neu und legen Sie die Thread-Aufgabe fest

3. Erstellen Sie ein Implementierungsklassenobjekt der Ausführbare Schnittstelle

4. Erstellen Sie ein Thread-Klassenobjekt und übergeben Sie das Implementierungsklassenobjekt der ausführbaren Schnittstelle in der Konstruktionsmethode

5. Rufen Sie die Startmethode in der Thread-Klasse auf, um einen neuen Thread zu starten um die run-Methode auszuführen

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
    }
}

Vorteile der Implementierung der Runnable-Schnittstelle zum Erstellen von Multithreads:

1. Vermeidung der Einschränkungen der Einzelvererbung:

Eine Klasse kann nur eine Klasse erben. Nachdem eine Klasse Thread geerbt hat, kann sie keine anderen Klassen erben.

Implementiert die Runnable-Schnittstelle und kann auch andere Klassen erben und andere Schnittstellen implementieren.

2. Verbessern Sie die Skalierbarkeit des Programms und reduzieren Sie die Kopplung des Programms

Die Möglichkeit, die Runnable-Schnittstelle zu implementieren, besteht darin, Thread-Einstellungsaufgaben und Thread-Startaufgaben zu trennen

Überschreiben Sie in der Implementierungsklasse die run()-Methode, um Thread-Aufgaben festzulegen.

Erstellen Sie ein Thread-Klassenobjekt und rufen Sie die start()-Methode auf, um einen neuen Thread zu starten.

sleep()-Methode, um die Methode in den Ruhezustand zu versetzen.

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 Empfohlene Tutorials zu verwandten Artikeln: Schnellstart mit Java

Das obige ist der detaillierte Inhalt vonImplementierung von Multithreading in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!