Java實(shí)現(xiàn)多線程的n種方法
Java 多線程實(shí)現(xiàn)的多種方法
在現(xiàn)代編程中，多線程是一項(xiàng)關(guān)鍵技術(shù)，它使得程序能夠同時(shí)執(zhí)行多個(gè)任務(wù)，提高了系統(tǒng)的效率和性能。在Java中，有多種方法可以實(shí)現(xiàn)多線程，每種方法都有其獨(dú)特的應(yīng)用場(chǎng)景和優(yōu)缺點(diǎn)。本文將詳細(xì)介紹幾種常見的Java多線程實(shí)現(xiàn)方法，包括基礎(chǔ)的Thread類、Runnable接口、高級(jí)的線程池、并發(fā)工具類、異步編程以及新的并發(fā)特性，幫助你深入理解多線程的不同實(shí)現(xiàn)方式。
1. Java多線程基礎(chǔ)概念
什么是線程？
線程是操作系統(tǒng)中最小的執(zhí)行單元。它包含了程序執(zhí)行的順序、調(diào)用棧、寄存器等資源。一個(gè)進(jìn)程可以包含多個(gè)線程，每個(gè)線程共享進(jìn)程的資源（如內(nèi)存、文件句柄等），但有自己的獨(dú)立執(zhí)行路徑。
為什么要使用多線程？
多線程允許程序同時(shí)執(zhí)行多個(gè)任務(wù)，從而最大化利用多核處理器的能力，提高程序的執(zhí)行效率。例如，GUI應(yīng)用程序可以在一個(gè)線程中處理用戶輸入，同時(shí)在另一個(gè)線程中執(zhí)行耗時(shí)的計(jì)算，避免界面卡頓。
Java中的線程模型
Java中的線程是基于操作系統(tǒng)的原生線程實(shí)現(xiàn)的，Java提供了java.lang.Thread類和java.lang.Runnable接口來(lái)支持多線程編程。Java 5及以后引入了更高級(jí)的并發(fā)工具，如Executor框架、并發(fā)工具類和異步編程模型，這些工具極大地簡(jiǎn)化了多線程編程的復(fù)雜性。
2. 繼承Thread類
最基礎(chǔ)的實(shí)現(xiàn)多線程的方法之一是繼承Thread類。通過(guò)繼承Thread類，可以直接使用類中的start()方法來(lái)啟動(dòng)線程。
實(shí)現(xiàn)方式
class MyThread extends Thread {
@Override
public void run() {
// 線程執(zhí)行的代碼
System.out.println("Thread is running...");
}
}
public class Main {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 啟動(dòng)線程
}
}
run()方法中包含了線程的執(zhí)行邏輯。start()方法會(huì)創(chuàng)建新線程，并自動(dòng)調(diào)用run()方法。
適用場(chǎng)景
繼承Thread類的方法適用于簡(jiǎn)單的多線程實(shí)現(xiàn)，特別是當(dāng)每個(gè)線程都是獨(dú)立的任務(wù)時(shí)。
優(yōu)缺點(diǎn)
優(yōu)點(diǎn)：
- 實(shí)現(xiàn)簡(jiǎn)單，直接繼承
Thread類并重寫run()方法即可。
- 實(shí)現(xiàn)簡(jiǎn)單，直接繼承
缺點(diǎn)：
- Java只允許單繼承，如果已經(jīng)繼承了其他類，則無(wú)法繼承
Thread類。 - 不適合復(fù)雜的多線程管理場(chǎng)景，如線程池管理。
- Java只允許單繼承，如果已經(jīng)繼承了其他類，則無(wú)法繼承
3. 實(shí)現(xiàn)Runnable接口
另一個(gè)實(shí)現(xiàn)多線程的基本方法是實(shí)現(xiàn)Runnable接口。與繼承Thread類不同，實(shí)現(xiàn)Runnable接口更靈活，因?yàn)樗试S類繼承其他類。
實(shí)現(xiàn)方式
class MyRunnable implements Runnable {
@Override
public void run() {
// 線程執(zhí)行的代碼
System.out.println("Runnable is running...");
}
}
public class Main {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start(); // 啟動(dòng)線程
}
}
適用場(chǎng)景
實(shí)現(xiàn)Runnable接口適用于需要實(shí)現(xiàn)多線程功能但不希望受限于Java單繼承機(jī)制的場(chǎng)景。它更適合將業(yè)務(wù)邏輯與線程控制分離的設(shè)計(jì)。
優(yōu)缺點(diǎn)
優(yōu)點(diǎn)：
- 可以通過(guò)實(shí)現(xiàn)接口實(shí)現(xiàn)多線程，不受Java單繼承機(jī)制的限制。
- 代碼更具可重用性，業(yè)務(wù)邏輯和線程控制分離。
缺點(diǎn)：
- 與繼承
Thread類相比，啟動(dòng)線程需要額外創(chuàng)建Thread對(duì)象。
- 與繼承
4. Callable和Future
Runnable接口的run()方法無(wú)法返回結(jié)果，也無(wú)法拋出異常。如果需要線程返回結(jié)果或拋出異常，可以使用Callable接口與Future結(jié)合使用。
介紹Callable接口
Callable接口是Java 5引入的一個(gè)功能更強(qiáng)的接口，它允許在執(zhí)行完任務(wù)后返回結(jié)果，并且可以拋出異常。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
// 線程執(zhí)行的代碼
return 123;
}
}
public class Main {
public static void main(String[] args) {
MyCallable callable = new MyCallable();
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();
try {
// 獲取線程返回的結(jié)果
Integer result = futureTask.get();
System.out.println("Thread result: " + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
Future的作用與實(shí)現(xiàn)
Future接口用來(lái)表示異步計(jì)算的結(jié)果。通過(guò)調(diào)用get()方法，可以等待計(jì)算完成并獲取結(jié)果。
應(yīng)用場(chǎng)景
當(dāng)線程需要返回計(jì)算結(jié)果，或在執(zhí)行過(guò)程中可能拋出異常時(shí)，Callable和Future是理想的選擇。
5. 使用Executor框架
在Java 5之前，開發(fā)者只能通過(guò)Thread類或Runnable接口手動(dòng)管理線程。隨著并發(fā)需求的增長(zhǎng)，Java 5引入了Executor框架，極大簡(jiǎn)化了線程管理。
線程池的概念
線程池是一組可重用的線程。通過(guò)線程池，可以避免頻繁創(chuàng)建和銷毀線程，提高性能。線程池還能幫助管理并發(fā)線程的數(shù)量，防止過(guò)多線程導(dǎo)致系統(tǒng)資源耗盡。
Executors類的使用
Executors類提供了多種方法來(lái)創(chuàng)建線程池，例如newFixedThreadPool()、newCachedThreadPool()和newSingleThreadExecutor()。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++) {
executor.execute(new RunnableTask(i));
}
executor.shutdown();
}
}
class RunnableTask implements Runnable {
private int taskId;
public RunnableTask(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("Task ID: " + this.taskId + " performed by " + Thread.currentThread().getName());
}
}
自定義線程池
如果需要更靈活的線程池配置，可以使用ThreadPoolExecutor類自定義線程池。
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Main {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, 4, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));
for (int i = 0; i < 10; i++) {
executor.execute(new RunnableTask(i));
}
executor.shutdown();
}
}
適用場(chǎng)景
線程池適用于高并發(fā)場(chǎng)景，可以有效管理和復(fù)用線程，避免頻繁創(chuàng)建和銷毀線程的開銷。
6. 并發(fā)工具類的使用
Java的并發(fā)包（java.util.concurrent）中提供了許多用于線程同步和協(xié)調(diào)的工具類。以下是幾種常用的工具類。
CountDownLatch
CountDownLatch用于多個(gè)線程等待某個(gè)事件完成。
import java.util.concurrent.CountDownLatch;
public class Main {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " is working...");
latch.countDown(); // 每個(gè)線程完成后調(diào)用countDown()
}).start();
}
latch.await(); // 等待所有線程完成
System.out.println("All threads have finished.");
}
}
CyclicBarrier
CyclicBarrier用于多個(gè)線程相互等待，直到所有線程到達(dá)屏障（Barrier）時(shí)再繼續(xù)執(zhí)行。
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Main {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("All parties have arrived at the barrier, let's proceed.");
});
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " is waiting at the barrier.");
try {
barrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " has crossed the barrier.");
}).start();
}
}
}
Semaphore
Semaphore用于控制同時(shí)訪問特定資源的線程數(shù)量。
import java.util.concurrent.Semaphore;
public class Main {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(2);
for (int i = 0; i < 5; i++) {
new Thread(() -> {
try {
semaphore.acquire(); // 獲取許可
System.out.println(Thread.currentThread().getName() + " is performing a task.");
Thread.sleep(2000);
semaphore.release(); // 釋放許可
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
}
Exchanger
Exchanger用于在兩個(gè)線程之間交換數(shù)據(jù)。
import java.util.concurrent.Exchanger;
public class Main {
public static void main(String[] args) {
Exchanger<String> exchanger = new Exchanger<>();
new Thread(() -> {
try {
String data = "Data from Thread A";
String receivedData = exchanger.exchange(data);
System.out.println("Thread A received: " + receivedData);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(() -> {
try {
String data = "Data from Thread B";
String receivedData = exchanger.exchange(data);
System.out.println("Thread B received: " + receivedData);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
Phaser
Phaser與CyclicBarrier類似，但它更靈活，允許線程動(dòng)態(tài)參與或離開。
import java.util.concurrent.Phaser;
public class Main {
public static void main(String[] args) {
Phaser phaser = new Phaser(3);
for (int i = 0; i < 3; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " is in phase " + phaser.getPhase());
phaser.arriveAndAwaitAdvance(); // 到達(dá)并等待其他線程
}).start();
}
phaser.arriveAndDeregister(); // 主線程離開，其他線程可繼續(xù)進(jìn)行
System.out.println("Main thread is deregistered from the phaser.");
}
}
適用場(chǎng)景
這些工具類適用于需要多個(gè)線程協(xié)同工作的場(chǎng)景，可以幫助開發(fā)者簡(jiǎn)化線程同步和協(xié)調(diào)邏輯。
7. Lock和Condition的使用
在Java 5之前，開發(fā)者只能使用synchronized關(guān)鍵字來(lái)實(shí)現(xiàn)線程同步。Java 5引入了Lock接口，提供了更靈活的鎖機(jī)制。
ReentrantLock
ReentrantLock是Lock接口的一個(gè)常用實(shí)現(xiàn)，支持重入鎖特性，允許線程重復(fù)獲取鎖而不發(fā)生死鎖。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private final Lock lock = new ReentrantLock();
public void performTask() {
lock.lock(); // 獲取鎖
try {
// 執(zhí)行任務(wù)
System.out.println(Thread.currentThread().getName() + " is performing a task.");
} finally {
lock.unlock(); // 釋放鎖
}
}
public static void main(String[] args) {
Main main = new Main();
for (int i = 0; i < 3; i++) {
new Thread(main::performTask).start();
}
}
}
Condition
Condition接口提供了比synchronized和wait/notify機(jī)制更靈活的線程間通信方式。通過(guò)Condition，可以實(shí)現(xiàn)更復(fù)雜的等待/通知模式。
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
private final Lock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
public void performTask() throws InterruptedException {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " is waiting.");
condition.await(); // 等待信號(hào)
System.out.println(Thread.currentThread().getName() + " is performing a task.");
} finally {
lock.unlock();
}
}
public void signalTask() {
lock.lock();
try {
System.out.println("Signal to perform the task.");
condition.signal(); // 發(fā)送信號(hào)
} finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
Main main = new Main();
new Thread(() -> {
try {
main.performTask();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
Thread.sleep(1000);
new Thread(main::signalTask).start();
}
}
適用場(chǎng)景
Lock和Condition適用于需要更靈活的線程控制和通信的場(chǎng)景，例如復(fù)雜的多線程同步、等待和通知機(jī)制。
8. 使用Fork/Join框架
Fork/Join框架是Java 7引入的，用于并行執(zhí)行任務(wù)。它是一個(gè)支持工作竊?。╳ork-stealing）算法的框架，適合用于可以被遞歸分解的任務(wù)。
ForkJoinPool和ForkJoinTask
ForkJoinPool是Fork/Join框架的核心，負(fù)責(zé)管理線程和任務(wù)。ForkJoinTask是所有任務(wù)的基類。
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
public class Main {
public static void main(String[] args) {
ForkJoinPool forkJoinPool = new ForkJoinPool();
long result = forkJoinPool.invoke(new SumTask(1, 100));
System.out.println("Sum from 1 to 100: " + result);
}
}
class SumTask extends RecursiveTask<Long> {
private final int start;
private final int end;
public SumTask(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
if (end - start <= 10) {
long sum = 0;
for (int i = start; i <= end; i++) {
sum += i;
}
return sum;
} else {
int middle = (start + end) / 2;
SumTask leftTask = new SumTask(start, middle);
SumTask rightTask = new SumTask(middle + 1, end);
leftTask.fork(); // 執(zhí)行子任務(wù)
return rightTask.compute() + leftTask.join(); // 合并結(jié)果
}
}
}
適用場(chǎng)景
Fork/Join框架適用于需要并行執(zhí)行的遞歸任務(wù)，例如大規(guī)模數(shù)據(jù)的處理和計(jì)算。
優(yōu)缺點(diǎn)
優(yōu)點(diǎn)：
- 利用工作竊取算法，可以最大化地利用多核處理器的性能。
缺點(diǎn)：
- 適用于特定類型的任務(wù)（如可以分解的任務(wù)），不適合所有場(chǎng)景。
9. 使用CompletableFuture實(shí)現(xiàn)異步編程
CompletableFuture是Java 8引入的類，它極大簡(jiǎn)化了異步編程，使得開發(fā)者可以以聲明式的方式編寫異步代碼。
簡(jiǎn)介CompletableFuture
CompletableFuture支持創(chuàng)建、組合、等待多個(gè)異步
任務(wù)，支持鏈?zhǔn)讲僮?，使代碼更簡(jiǎn)潔。
import java.util.concurrent.CompletableFuture;
public class Main {
public static void main(String[] args) throws InterruptedException {
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
System.out.println("Async task is running.");
});
future.thenRun(() -> System.out.println("Async task finished."));
Thread.sleep(2000); // 等待異步任務(wù)完成
}
}
組合多個(gè)異步任務(wù)
可以使用thenCombine、thenAcceptBoth等方法組合多個(gè)異步任務(wù)的結(jié)果。
import java.util.concurrent.CompletableFuture;
public class Main {
public static void main(String[] args) throws InterruptedException {
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
return 10;
});
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
return 20;
});
CompletableFuture<Integer> result = future1.thenCombine(future2, (x, y) -> x + y);
result.thenAccept(sum -> System.out.println("Sum: " + sum));
Thread.sleep(2000); // 等待異步任務(wù)完成
}
}
處理異步計(jì)算的結(jié)果
可以使用thenApply、thenAccept等方法處理異步計(jì)算的結(jié)果。
import java.util.concurrent.CompletableFuture;
public class Main {
public static void main(String[] args) throws InterruptedException {
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
return 10;
});
future.thenApply(result -> result * 2)
.thenAccept(finalResult -> System.out.println("Final Result: " + finalResult));
Thread.sleep(2000); // 等待異步任務(wù)完成
}
}
適用場(chǎng)景
CompletableFuture適用于需要處理復(fù)雜異步流程的場(chǎng)景，例如并發(fā)處理多個(gè)獨(dú)立任務(wù)，并將結(jié)果組合成最終輸出。
結(jié)論
Java 提供了多種實(shí)現(xiàn)多線程的方法，每種方法都有其特定的應(yīng)用場(chǎng)景和優(yōu)缺點(diǎn)。開發(fā)者在實(shí)際項(xiàng)目中，應(yīng)根據(jù)需求選擇合適的實(shí)現(xiàn)方式，并遵循多線程編程的最佳實(shí)踐，以確保程序的穩(wěn)定性和性能。
通過(guò)掌握這些多線程實(shí)現(xiàn)方式，開發(fā)者可以在高并發(fā)環(huán)境中開發(fā)出高效、可靠的應(yīng)用程序。在未來(lái)的開發(fā)中，隨著硬件性能的不斷提升和多核處理器的普及，掌握并發(fā)編程將成為每一個(gè)Java開發(fā)者的必備技能。
以上就是Java實(shí)現(xiàn)多線程的n種方法的詳細(xì)內(nèi)容，更多關(guān)于Java實(shí)現(xiàn)多線程的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
springboot整合liteflow的實(shí)現(xiàn)示例
本文主要介紹了在Spring Boot項(xiàng)目中整合Liteflow規(guī)則引擎,文中通過(guò)示例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2024-12-12
Java高級(jí)用法中的JNA類型映射注意細(xì)節(jié)及使用問題
本文介紹了在使用JNA方法映射中應(yīng)該注意的一些細(xì)節(jié)和具體的使用問題，對(duì)java??JNA類型映射注意細(xì)節(jié)感興趣的朋友一起看看吧2022-04-04
使用SpringBoot+EasyExcel+Vue實(shí)現(xiàn)excel表格的導(dǎo)入和導(dǎo)出詳解
這篇文章主要介紹了使用SpringBoot+VUE+EasyExcel?整合導(dǎo)入導(dǎo)出數(shù)據(jù)的過(guò)程詳解，本文給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下2022-08-08
Java?synchronized關(guān)鍵字性能考量及優(yōu)化探索
這篇文章主要為大家介紹了Java?synchronized關(guān)鍵字性能考量及優(yōu)化探索示例分析,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪2023-12-12
MyBatis實(shí)現(xiàn)批量插入數(shù)據(jù),多重forEach循環(huán)
這篇文章主要介紹了MyBatis實(shí)現(xiàn)批量插入數(shù)據(jù),多重forEach循環(huán)方式，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2022-02-02
Spring Boot監(jiān)視器是一個(gè)用于監(jiān)控和管理Spring Boot應(yīng)用程序的工具集,本文就來(lái)介紹一下SpringBoot監(jiān)視器的具體使用,感興趣的可以了解一下2025-01-01
SpringBoot+vue+Axios實(shí)現(xiàn)Token令牌的詳細(xì)過(guò)程
Token是在服務(wù)端產(chǎn)生的,前端可以使用用戶名/密碼向服務(wù)端請(qǐng)求認(rèn)證（登錄）,服務(wù)端認(rèn)證成功,服務(wù)端會(huì)返回?Token?給前端,Token可以使用自己的算法自定義,本文給大家介紹SpringBoot+vue+Axios實(shí)現(xiàn)Token令牌,感興趣的朋友一起看看吧2023-10-10
SpringBoot配置數(shù)據(jù)庫(kù)密碼加密的方法
由于系統(tǒng)安全的考慮,配置文件中不能出現(xiàn)明文密碼的問題,本文就給大家詳細(xì)介紹下springboot配置數(shù)據(jù)庫(kù)密碼加密的方法,下面話不多說(shuō)了,來(lái)一起看看詳細(xì)的介紹吧,需要的朋友可以參考下2023-08-08
Java System類詳解_動(dòng)力節(jié)點(diǎn)Java學(xué)院整理
System類是jdk提供的一個(gè)工具類，有final修飾，不可繼承，由名字可以看出來(lái)，其中的操作多數(shù)和系統(tǒng)相關(guān)。這篇文章主要介紹了Java System類詳解_動(dòng)力節(jié)點(diǎn)Java學(xué)院整理,需要的朋友可以參考下2017-04-04
眾所周知java提供了很多字符串截取的方式,下面這篇文章主要給大家總結(jié)介紹了關(guān)于Java截取字符串的幾種方法,文中通過(guò)實(shí)例代碼介紹的非常詳細(xì),需要的朋友可以參考下2023-04-04