So implementieren Sie Java-Multithreading

So implementieren Sie Multithreading in Java: (Empfohlen: Java-Video-Tutorial)

Methode 1: Erben Sie die Thread-Klasse

1. Erstellen Sie eine Unterklasse, die von der Thread-Klasse erbt

2. Schreiben Sie run() in der Thread-Klasse neu: Deklarieren Sie die von diesem Thread auszuführende Operation in run().

3. Erstellen Sie ein Objekt einer Unterklasse von Thread

4. Rufen Sie start() dieses Objekts auf: ① Starten Sie den Thread ② Rufen Sie die run()-Methode des aktuellen Threads auf

Methode 2: So implementieren Sie die Runnable-Schnittstelle

1. Erstellen Sie eine Klasse, die die Runnable-Schnittstelle implementiert

2. Implementieren Sie die abstrakte Methode in der Runnable-Schnittstelle : run(): wird erstellt Die vom Thread auszuführenden Operationen werden in dieser Methode deklariert

3 Erstellen Sie ein Objekt der Runnable-Schnittstellenimplementierungsklasse

4. Übergeben Sie dieses Objekt als Parameter an den Konstruktor der Thread-Klasse, um das Thread-Klassenobjekt zu erstellen

5. Rufen Sie start() in der Thread-Klasse auf: ① Starten Sie den Thread ② Rufen Sie run() des Threads auf ---> die run() der Runnable-Schnittstellen-Implementierungsklasse

wie folgt. Die beiden Methoden sind neu in jdk1.5!

Methode 3: Implementieren Sie die Callable-Schnittstelle

Erklärung:

1. Im Vergleich zur Verwendung von Runnable ist Callable leistungsfähiger

2. Im Vergleich zur run()-Methode kann die implementierte call()-Methode Werte zurückgeben

3. Die Methode kann Ausnahmen auslösen

4. Unterstützt generische Rückgabewerte

5. Sie müssen die FutureTask-Klasse verwenden, um beispielsweise die Rückgabeergebnisse abzurufen

Die Future-Schnittstelle kann die Ausführungsergebnisse bestimmter ausführbarer und aufrufbarer Aufgaben abbrechen, abfragen, ob sie abgeschlossen ist, die Ergebnisse abrufen usw. FutureTask ist die einzige Implementierungsklasse der Future-Schnittstelle. FutureTask implementiert auch die Schnittstellen Runnable und Future. Es kann von einem Thread als Runnable ausgeführt werden und kann auch als Future verwendet werden, um den Rückgabewert des Callable zu erhalten

Methode 4: Verwenden Sie den Thread-Pool

Anleitung:

Erstellen Sie im Voraus mehrere Threads, legen Sie sie in den Thread-Pool ab, erhalten Sie sie direkt bei der Verwendung und legen Sie sie nach der Verwendung wieder in den Pool ein. Dadurch kann eine häufige Erstellung und Zerstörung vermieden und eine Wiederverwendung realisiert werden. Ähnlich wie die öffentlichen Verkehrsmittel im Leben.

Vorteile:

1. Verbessert die Reaktionsgeschwindigkeit (reduziert die Zeit zum Erstellen neuer Threads)

2. Reduziert den Ressourcenverbrauch (Threads im Thread-Pool wiederverwenden, keine Notwendigkeit). Wird jedes Mal erstellt)

3. Bequeme Thread-Verwaltung

Beispiel:

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ThreadPoolExecutor;

//方式一
class ThreadTest extends Thread {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}

// 方式二
class RunnableTest implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}
}

// 方式三
class CallableTest implements Callable<Integer> {

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
			sum += i;
		}
		return sum;
	}

}

// 方式四
class ThreadPool implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

}

public class Test {
	public static void main(String[] args) {
		// 继承Thread
		ThreadTest thread = new ThreadTest();
		thread.setName("方式一");
		thread.start();

		// 实现Runnable
		RunnableTest runnableTest = new RunnableTest();
		Thread thread2 = new Thread(runnableTest, "方式二");
		thread2.start();

		// 实现Callable<> 有返回值
		CallableTest callableTest = new CallableTest();
		FutureTask<Integer> futureTask = new FutureTask<>(callableTest);
		new Thread(futureTask, "方式三").start();
		// 返回值
		try {
			Integer integer = futureTask.get();
			System.out.println("返回值（sum）：" + integer);
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 线程池
		ExecutorService pool = Executors.newFixedThreadPool(10);

		ThreadPoolExecutor executor = (ThreadPoolExecutor) pool;
		/*
		 * 可以做一些操作:
		 * corePoolSize：核心池的大小 
		 * maximumPoolSize：最大线程数
		 * keepAliveTime：线程没任务时最多保持多长时间后会终止
		 */
		executor.setCorePoolSize(5);

		// 开启线程
		executor.execute(new ThreadPool());
		executor.execute(new ThreadPool());
		executor.execute(new ThreadPool());
		executor.execute(new ThreadPool());

	}

}

Für weitere Java-Kenntnisse beachten Sie bitte die Spalte Java Basic Tutorial .

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