Comment implémenter le multithreading Java

Comment implémenter le multi-threading en Java : (Recommandé : Tutoriel vidéo Java)

Méthode 1 : Hériter de la classe Thread

1. Créez une sous-classe qui hérite de la classe Thread

2 Réécrivez run() dans la classe Thread : déclarez l'opération à effectuer par ce thread dans run().

3. Créez un objet d'une sous-classe de Thread

4. Appelez start() de cet objet : ① Démarrez le thread ② Appelez la méthode run() du thread actuel

Méthode 2 : Comment implémenter l'interface Runnable

1. Créez une classe qui implémente l'interface Runnable

2. Implémentez la méthode abstraite dans l'interface Runnable. : run() : va créer Les opérations à effectuer par le thread sont déclarées dans cette méthode

3 Créer un objet de la classe d'implémentation de l'interface Runnable

4. paramètre au constructeur de la classe Thread pour créer l'objet de classe Thread

5. Appelez start() dans la classe Thread : ① Démarrez le thread ② Appelez le run() du thread ---> le run() de la classe d'implémentation de l'interface Runnable

comme suit Les deux méthodes sont nouvelles dans jdk1.5 !

Méthode 3 : Implémenter l'interface Callable

Explication :

1 Par rapport à l'utilisation de Runnable, Callable est plus puissant

. 2. Par rapport à la méthode run(), la méthode call() implémentée peut renvoyer des valeurs

3 La méthode peut lever des exceptions

4. Prend en charge les valeurs de retour génériques

. 5. Vous devez utiliser la classe FutureTask, par exemple pour obtenir les résultats de retour

L'interface Future peut annuler les résultats d'exécution de tâches Runnable et Callable spécifiques, demander si elle est terminée, obtenir les résultats, etc. FutureTask est la seule classe d'implémentation de l'interface FutureTask implémente également les interfaces Runnable et Future. Il peut être exécuté par un thread en tant que Runnable, et peut également être utilisé comme Future pour obtenir la valeur de retour du Callable

Méthode 4 : Utiliser le pool de threads

Instructions :

Créez plusieurs threads à l'avance, placez-les dans le pool de threads, obtenez-les directement lorsqu'ils sont utilisés et remettez-les dans le pool après utilisation. Cela peut éviter la création et la destruction fréquentes et réaliser la réutilisation. Semblable aux transports en commun dans la vie.

Avantages :

1. Améliore la vitesse de réponse (réduit le temps de création de nouveaux threads)

2. Réduisez la consommation de ressources (réutilisez les threads dans le pool de threads, pas besoin de le faire). Créé à chaque fois)

3. Gestion pratique des threads

Exemple :

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());

	}

}

Pour plus de connaissances sur Java, veuillez faire attention à la colonne Tutoriel de base 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!