1、繼承Thread類，重寫run()方法

//方式1

package cn.itcats.thread.Test1;public class Demo1 extends Thread{//重寫的是父類Thread的run()public void run() {System.out.println(getName()+"is running...");}public static void main(String[] args) {Demo1 demo1 = new Demo1();Demo1 demo2 = new Demo1();demo1.start();demo2.start();} }

2、實現Runnable接口，重寫run()

實現Runnable接口只是完成了線程任務的編寫
若要啟動線程，需要new Thread(Runnable target)，再有thread對象調用start()方法啟動線程
此處我們只是重寫了Runnable接口的Run()方法，并未重寫Thread類的run()，讓我們看看Thread類run()的實現
本質上也是調用了我們傳進去的Runnale target對象的run()方法

//Thread類源碼中的run()方法 //target為Thread 成員變量中的 private Runnable target;@Overridepublic void run() {if (target != null) {target.run();}}

所以第二種創建線程的實現代碼如下：

package cn.itcats.thread.Test1;/*** 第二種創建啟動線程的方式* 實現Runnale接口* @author fatah*/ public class Demo2 implements Runnable{//重寫的是Runnable接口的run()public void run() {System.out.println("implements Runnable is running");}public static void main(String[] args) {Thread thread1 = new Thread(new Demo2());Thread thread2 = new Thread(new Demo2());thread1.start();thread2.start();} }

實現Runnable接口相比第一種繼承Thread類的方式，使用了面向接口，將任務與線程進行分離，有利于解耦

3、匿名內部類的方式

適用于創建啟動線程次數較少的環境，書寫更加簡便
具體代碼實現：

package cn.itcats.thread.Test1; /*** 創建啟動線程的第三種方式————匿名內部類* @author fatah*/ public class Demo3 {public static void main(String[] args) {//方式1：相當于繼承了Thread類，作為子類重寫run()實現new Thread() {public void run() {System.out.println("匿名內部類創建線程方式1...");};}.start();//方式2:實現Runnable,Runnable作為匿名內部類new Thread(new Runnable() {public void run() {System.out.println("匿名內部類創建線程方式2...");}} ).start();} }

4、帶返回值的線程(實現implements Callable<返回值類型>)

以上兩種方式，都沒有返回值且都無法拋出異常。
Callable和Runnbale一樣代表著任務，只是Callable接口中不是run()，而是call()方法，但兩者相似，即都表示執行任務，call()方法的返回值類型即為Callable接口的泛型
具體代碼實現：

package cn.itcats.thread.Test1;import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.FutureTask; import java.util.concurrent.RunnableFuture;/*** 方式4:實現Callable<T> 接口* 含返回值且可拋出異常的線程創建啟動方式* @author fatah*/ public class Demo5 implements Callable<String>{public String call() throws Exception {System.out.println("正在執行新建線程任務");Thread.sleep(2000);return "新建線程睡了2s后返回執行結果";} public static void main(String[] args) throws InterruptedException, ExecutionException {Demo5 d = new Demo5();/* call()只是線程任務,對線程任務進行封裝class FutureTask<V> implements RunnableFuture<V>interface RunnableFuture<V> extends Runnable, Future<V>*/FutureTask<String> task = new FutureTask<>(d);Thread t = new Thread(task);t.start();System.out.println("提前完成任務...");//獲取任務執行后返回的結果String result = task.get();System.out.println("線程執行結果為"+result);} }

5、定時器(java.util.Timer)

關于Timmer的幾個構造方法

執行定時器任務使用的是schedule方法：

package cn.itcats.thread.Test1;import java.util.Timer; import java.util.TimerTask; /*** 方法5：創建啟動線程之Timer定時任務* @author fatah*/ public class Demo6 {public static void main(String[] args) {Timer timer = new Timer();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("定時任務延遲0(即立刻執行),每隔1000ms執行一次");}}, 0, 1000);} }

我們發現Timer有不可控的缺點，當任務未執行完畢或我們每次想執行不同任務時候，實現起來比較麻煩。這里推薦一個比較優秀的開源作業調度框架“quartz”。

6、線程池的實現(java.util.concurrent.Executor接口)

降低了創建線程和銷毀線程時間開銷和資源浪費
具體代碼實現：

package cn.itcats.thread.Test1;import java.util.concurrent.Executor; import java.util.concurrent.Executors;public class Demo7 {public static void main(String[] args) {//創建帶有5個線程的線程池//返回的實際上是ExecutorService,而ExecutorService是Executor的子接口Executor threadPool = Executors.newFixedThreadPool(5);for(int i = 0 ;i < 10 ; i++) {threadPool.execute(new Runnable() {public void run() {System.out.println(Thread.currentThread().getName()+" is running");}});}} } 運行結果： pool-1-thread-3 is running pool-1-thread-1 is running pool-1-thread-4 is running pool-1-thread-3 is running pool-1-thread-5 is running pool-1-thread-2 is running pool-1-thread-5 is running pool-1-thread-3 is running pool-1-thread-1 is running pool-1-thread-4 is running

運行完畢，但程序并未停止，原因是線程池并未銷毀，若想銷毀調用threadPool.shutdown(); 注意需要把我上面的
Executor threadPool = Executors.newFixedThreadPool(10); 改為
ExecutorService threadPool = Executors.newFixedThreadPool(10); 否則無shutdown()方法

若創建的是CachedThreadPool則不需要指定線程數量，線程數量多少取決于線程任務，不夠用則創建線程，夠用則回收。

7、Lambda表達式的實現(parallelStream)

package cn.itcats.thread.Test1;import java.util.ArrayList; import java.util.Arrays; import java.util.List;/*** 使用Lambda表達式并行計算* parallelStream* @author fatah*/ public class Demo8 {public static void main(String[] args) {List<Integer> list = Arrays.asList(1,2,3,4,5,6);Demo8 demo = new Demo8();int result = demo.add(list);System.out.println("計算后的結果為"+result);}public int add(List<Integer> list) {//若Lambda是串行執行,則應順序打印list.parallelStream().forEach(System.out :: println);//Lambda有stream和parallelSteam(并行)return list.parallelStream().mapToInt(i -> i).sum();} } 運行結果： 4 1 3 5 6 2 計算后的結果為21 事實證明是并行執行

8、Spring實現多線程

(1)新建Maven工程導入spring相關依賴
(2)新建一個java配置類(注意需要開啟@EnableAsync注解——支持異步任務)

package cn.itcats.thread;import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableAsync;@Configuration @ComponentScan("cn.itcats.thread") @EnableAsync public class Config {}

(3)書寫異步執行的方法類(注意方法上需要有@Async——異步方法調用)

package cn.itcats.thread;import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service;@Service public class AsyncService {@Asyncpublic void Async_A() {System.out.println("Async_A is running");}@Asyncpublic void Async_B() {System.out.println("Async_B is running");} }

(4)創建運行類

package cn.itcats.thread;import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class Run {public static void main(String[] args) {//構造方法傳遞Java配置類Config.classAnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);AsyncService bean = ac.getBean(AsyncService.class);bean.Async_A();bean.Async_B();} }

文章轉自

總結

以上是生活随笔為你收集整理的Java创建多线程的8种代码方式的全部內容，希望文章能夠幫你解決所遇到的問題。

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