java實現多線程的方法

方式一：繼承Thread類的方式

1、創建一個繼承于Thread類的子類

2、重寫Thread類中的run()：將此線程要執行的操作聲明在run()

3、創建Thread的子類的對象

4、調用此對象的start():①啟動線程 ②調用當前線程的run()方法

方式二：實現Runnable接口的方式

1、創建一個實現Runnable接口的類

2、實現Runnable接口中的抽象方法：run():將創建的線程要執行的操作聲明在此方法中

3、創建Runnable接口實現類的對象

4、將此對象作為參數傳遞到Thread類的構造器中，創建Thread類的對象

5、調用Thread類中的start():① 啟動線程  ② 調用線程的run() --->調用Runnable接口實現類的run()

以下兩種方式是jdk1.5新增的！

方式三：實現Callable接口

說明：

1、與使用Runnable相比， Callable功能更強大些

2、實現的call()方法相比run()方法，可以返回值

3、方法可以拋出異常

4、支持泛型的返回值

5、需要借助FutureTask類，比如獲取返回結果

Future接口可以對具體Runnable、Callable任務的執行結果進行取消、查詢是否完成、獲取結果等。FutureTask是Futrue接口的唯一的實現類FutureTask 同時實現了Runnable, Future接口。它既可以作為Runnable被線程執行，又可以作為Future得到Callable的返回值

方式四：使用線程池

說明：

提前創建好多個線程，放入線程池中，使用時直接獲取，使用完放回池中。可以避免頻繁創建銷毀、實現重復利用。類似生活中的公共交通工具。

好處：

1、提高響應速度（減少了創建新線程的時間）

2、降低資源消耗（重復利用線程池中線程，不需要每次都創建）

3、便于線程管理

示例：

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

	}

}

以上就是java多線程如何實現的詳細內容，更多請關注億速云其它相關文章！