1.實現Runnable接口，重載run()，無返回值

package thread;

public class ThreadRunnable implements Runnable {

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(Thread.currentThread().getName() + ":" + i);

}

}

}

package thread;

public class ThreadMain {

public static void main(String[] args) throws Exception {

ThreadRunnable threadRunnable1 = new ThreadRunnable();

ThreadRunnable threadRunnable2 = new ThreadRunnable();

ThreadRunnable threadRunnable3 = new ThreadRunnable();

ThreadRunnable threadRunnable4 = new ThreadRunnable();

Thread thread1 = new Thread(threadRunnable1);

Thread thread2 = new Thread(threadRunnable2);

Thread thread3 = new Thread(threadRunnable3);

Thread thread4 = new Thread(threadRunnable4);

thread1.start();

thread2.start();

thread3.start();

thread4.start();

}

}

2.繼承Thread類，復寫run()

使用時通過調用Thread的start()(該方法是native)，再調用創建線程的run()，不同線程的run方法里面的代碼交替執行。

不足：由于java為單繼承，若使用線程類已經有個父類，則不能使用該方式創建線程。

public class ThreadEx extends Thread {

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(Thread.currentThread() + ":" + i);

}

}

}

public class ThreadMain {

public static void main(String[] args)

{

ThreadEx threadEx = new ThreadEx();

threadEx.start();

}

}

3.實現Callable接口，通過FutureTask/Future來創建有返回值的Thread線程，通過Executor執行

補充：與實現Runnable接口類似，都是實現接口，不同的是該方式有返回值，可以獲得異步執行的結果。

延伸：FutureTask是類，Future是接口。

package thread;

import java.util.concurrent.*;

public class ThreadCallable {

public static void main(String[] args) throws Exception {

FutureTask futureTask = new FutureTask(new Callable() {

public Integer call() throws Exception {

for (int i = 0; i < 10; i++) {

System.out.println(Thread.currentThread().getName() + ":" + i);

}

return 1;

}

});

Executor executor = Executors.newFixedThreadPool(1);

((ExecutorService) executor).submit(futureTask);

//獲得線程執行狀態

System.out.println(Thread.currentThread().getName() + ":" + futureTask.get());

}

}

4.使用Executors創建ExecutorService，入參Callable或Future

補充：適用于線程池和并發

package thread;

import java.util.concurrent.Callable;

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadFactory;

import static java.lang.Thread.sleep;

public class ThreadExecutors {

private final String threadName;

public ThreadExecutors(String threadName) {

this.threadName = threadName;

}

private ThreadFactory createThread() {

ThreadFactory tf = new ThreadFactory() {

public Thread newThread(Runnable r) {

Thread thread = new Thread();

thread.setName(threadName);

thread.setDaemon(true);

try {

sleep(1000);

}

catch (InterruptedException e) {

e.printStackTrace();

}

return thread;

}

};

return tf;

}

public Object runCallable(Callable callable) {

return Executors.newSingleThreadExecutor(createThread()).submit(callable);

}

public Object runFunture(Runnable runnable) {

return Executors.newSingleThreadExecutor(createThread()).submit(runnable);

}

}

package thread;

import java.util.concurrent.*;

public class ThreadMain {

public static void main(String[] args) throws Exception {

ThreadExecutors threadExecutors = new ThreadExecutors("callableThread");

threadExecutors.runCallable(new Callable() {

public String call() throws Exception {

return "success";

}

});

threadExecutors.runFunture(new Runnable() {

public void run() {

System.out.println("execute runnable thread.");

}

});

}

}

5?Runnable接口和Callable接口區別

1)兩個接口需要實現的方法名不一樣，Runnable需要實現的方法為run()，Callable需要實現的方法為call()。

2)實現的方法返回值不一樣，Runnable任務執行后無返回值，Callable任務執行后可以得到異步計算的結果。

3)拋出異常不一樣，Runnable不可以拋出異常，Callable可以拋出異常。

6 Callable返回值意義在哪兒，不要返回值可以嗎，什么時候需要用到返回值？

首先Callable是線程異步執行的結果狀態，如果有兩個線程A和B，B中的某個業務邏輯中需要確定A結束后才能進行，那么就需要獲得線程A的執行結果。

設計背景：一個任務需要進行一系列操作，比如拷貝大量的基礎數據，以及解析數據，并入庫，由于數量大，整個過程需要持續十秒左右，用戶體驗差，需要降低到2~5s。

設計思路：經過分解過程，將拷貝數據分為一個過程，同時涵蓋部分解析數據功能，剩下解析數據劃為一個過程，兩個過程異步執行，其中最后一個任務狀態入庫時需要將所有業務操作都執行完成后更新，此時就需要用到線程中的返回值。

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的java 镶嵌创建线程_Java多线程——之一创建线程的四种方法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。