掌握這五種多線程方法，提高Java代碼效率
如果您的應(yīng)用程序與那些能夠同時處理多個任務(wù)的應(yīng)用程序相比表現(xiàn)不佳，很可能是因為它是單線程的。解決這個問題的方法之一是采用多線程技術(shù)。
以下是一些可以考慮的方法：
- 線程（Thread）
- 并行流（Parallel Streams）
- ExecutorService
- ForkJoinPool
- CompletableFuture
適當(dāng)?shù)厥褂眠@些方法，可以徹底改變您的應(yīng)用程序，并推動您的職業(yè)發(fā)展。下面我們來看看如何將您的應(yīng)用程序轉(zhuǎn)變?yōu)楦咝У亩嗑€程應(yīng)用。
1. 線程（Thread）
第一種選擇是使用線程（Thread）類。通過這種方式，您可以直接控制線程的創(chuàng)建和管理。以下是一個示例：
CustomTask 每隔50毫秒從0數(shù)到 count - 1。
public class CustomTask implements Runnable {
private final String name;
private final int count;
CustomTask(String name, int count) {
this.name = name;
this.count = count;
}
@Override
public void run() {
for (int i = 0; i < count; i++) {
System.out.println(name + "-" + i + " from " +
Thread.currentThread().getName());
try {
Thread.sleep(50);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}a、b 和 c 是該類的三個實例。
Thread a = new Thread(new CustomTask("a", 5));
Thread b = new Thread(new CustomTask("b", 10));
Thread c = new Thread(new CustomTask("c", 5));請注意，b 預(yù)計計數(shù)的次數(shù)是其他實例的兩倍。您希望在 a 和 c 順序運行的同時運行 b。
您可以非常容易地實現(xiàn)這種行為。
// 首先啟動 a 和 b。
a.start();
b.start();
// a 完成后開始 c。
a.join();
c.start();以下是結(jié)果:
a-0 from Thread-0
b-0 from Thread-1
b-1 from Thread-1
a-1 from Thread-0
b-2 from Thread-1
a-2 from Thread-0
b-3 from Thread-1
a-3 from Thread-0
b-4 from Thread-1
a-4 from Thread-0
b-5 from Thread-1
c-0 from Thread-2
b-6 from Thread-1
c-1 from Thread-2
b-7 from Thread-1
c-2 from Thread-2
b-8 from Thread-1
c-3 from Thread-2
b-9 from Thread-1
c-4 from Thread-2a 和 b 同時開始運行，輪流輸出。a 完成后，c 開始執(zhí)行。此外，它們?nèi)吭诓煌木€程中運行。通過手動創(chuàng)建 Thread 實例，您可以完全控制它們。
然而，請注意，低級線程處理也需要同步和資源管理，這可能更容易出錯和復(fù)雜。
2. 并行流（Parallel Streams）
當(dāng)您需要對大型集合中的所有元素應(yīng)用相同、重復(fù)且獨立的任務(wù)時，并行流非常有效。
例如，圖像調(diào)整大小是一個需要按順序運行的繁重任務(wù)；當(dāng)您有多個圖像需要調(diào)整大小時，如果按順序執(zhí)行，將需要很長時間才能完成。在這種情況下，您可以使用并行流并行調(diào)整它們的大小，如下所示。
private static List<BufferedImage> resizeAll(List<BufferedImage> sourceImages,
int width, int height) {
return sourceImages
.parallelStream()
.map(source -> resize(source, width, height))
.toList();
}這樣，圖像將同時調(diào)整大小，節(jié)省了大量寶貴的時間。
3. ExecutorService
當(dāng)實現(xiàn)不需要精確的線程控制時，可以考慮使用 ExecutorService。ExecutorService 提供了更高層次的線程管理抽象，包括線程池、任務(wù)調(diào)度和資源管理。
ExecutorService 是一個接口，它最常見的用法是線程池。假設(shè)您有大量的異步任務(wù)堆積在一起，但是同時運行所有任務(wù)——每個任務(wù)占用一個線程——似乎太多了。線程池可以通過限制最大線程數(shù)來幫助您。
下面的示例中，我們使用 Executors.newFixedThreadPool() 實例化 ExecutorService 來使用 3 個線程運行 10 個任務(wù)。每個任務(wù)只打印一行。請注意，我們在之前的部分中重用了之前定義的 CustomTask。
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
executorService.submit(new CustomTask(String.valueOf(i), 1));
}
executorService.shutdown();這將打印以下結(jié)果:
0-0 from pool-1-thread-1
2-0 from pool-1-thread-3
1-0 from pool-1-thread-2
4-0 from pool-1-thread-3
3-0 from pool-1-thread-2
5-0 from pool-1-thread-1
6-0 from pool-1-thread-1
7-0 from pool-1-thread-3
8-0 from pool-1-thread-2
9-0 from pool-1-thread-310 個任務(wù)在 3 個線程中運行。通過限制特定任務(wù)使用的線程數(shù)，您可以根據(jù)優(yōu)先級分配線程數(shù)：對于重要且頻繁的任務(wù)使用更多線程，對于瑣碎或偶爾的任務(wù)使用較少線程。ExecutorService 具有高效和簡潔的特點，是大多數(shù)多線程場景的首選選項。
如果您需要更多的控制和靈活性，請查看 ThreadPoolExecutor，它是 Executors.newFixedThreadPool() 返回的 ExecutorService 的實際實現(xiàn)。您可以直接創(chuàng)建其實例或?qū)⒎祷氐?nbsp;ExecutorService 實例轉(zhuǎn)換為 ThreadPoolExecutor 實例以獲得更多控制權(quán)。
4. ForkJoinPool
ForkJoinPool是另一種線程池，正如其名稱所示。雖然它在許多其他異步方法的底層使用中，但對于可以分解為較小且獨立子任務(wù)的任務(wù)來說，它也非常強大，這些任務(wù)可以通過分而治之的策略來解決。
其中一個任務(wù)是圖像調(diào)整大小。圖像調(diào)整大小是分而治之問題的一個很好的例子。使用ForkJoinPool，您可以將圖像分成兩個或四個較小的圖像，并同時調(diào)整它們的大小。以下是ImageResizeAction的示例，它將圖像調(diào)整為給定的大小。
package multithreading;
import java.awt.image.BufferedImage;
import java.util.concurrent.RecursiveAction;
public class ImageResizeAction extends RecursiveAction {
private static final int THRESHOLD = 100;
private final BufferedImage sourceImage;
private final BufferedImage targetImage;
private final int startRow;
private final int endRow;
private final int targetWidth;
private final int targetHeight;
public ImageResizeAction(BufferedImage sourceImage,
BufferedImage targetImage,
int startRow, int endRow,
int targetWidth, int targetHeight) {
this.sourceImage = sourceImage;
this.targetImage = targetImage;
this.startRow = startRow;
this.endRow = endRow;
this.targetWidth = targetWidth;
this.targetHeight = targetHeight;
}
@Override
protected void compute() {
if (endRow - startRow <= THRESHOLD) {
resizeImage();
} else {
int midRow = startRow + (endRow - startRow) / 2;
invokeAll(
new ImageResizeAction(sourceImage, targetImage,
startRow, midRow, targetWidth, targetHeight),
new ImageResizeAction(sourceImage, targetImage,
midRow, endRow, targetWidth, targetHeight)
);
}
}
private void resizeImage() {
int sourceWidth = sourceImage.getWidth();
double xScale = (double) targetWidth / sourceWidth;
double yScale = (double) targetHeight / sourceImage.getHeight();
for (int y = startRow; y < endRow; y++) {
for (int x = 0; x < sourceWidth; x++) {
int targetX = (int) (x * xScale);
int targetY = (int) (y * yScale);
int rgb = sourceImage.getRGB(x, y);
targetImage.setRGB(targetX, targetY, rgb);
}
}
}
}請注意，ImageResizeAction繼承了RecursiveAction。RecursiveAction用于定義遞歸的調(diào)整大小操作。在此示例中，圖像被分成兩半并并行調(diào)整大小。
您可以使用以下代碼運行ImageResizeAction：
public static void main(String[] args) throws IOException {
String sourceImagePath = "source_image.jpg";
String targetImagePath = "target_image.png";
int targetWidth = 300;
int targetHeight = 100;
BufferedImage sourceImage = ImageIO.read(new File(sourceImagePath));
BufferedImage targetImage = new BufferedImage(targetWidth, targetHeight,
BufferedImage.TYPE_INT_RGB);
ForkJoinPool forkJoinPool = new ForkJoinPool();
forkJoinPool.invoke(new ImageResizeAction(sourceImage, targetImage,
0, sourceImage.getHeight(), targetWidth, targetHeight));
ImageIO.write(targetImage, "png", new File(targetImagePath));
System.out.println("圖像調(diào)整大小成功！");
}借助ForkJoinPool的幫助，您現(xiàn)在能夠更高效地調(diào)整圖像的大小，具有更好的可伸縮性，并最大程度地利用資源。
5. CompletableFuture
通過CompletableFuture，您可以完全發(fā)揮Future的功能，并擁有許多額外的特性。其中最突出的功能是它能夠鏈?zhǔn)降剡B接異步操作，使您能夠構(gòu)建復(fù)雜的異步管道。
public static void main(String[] args) {
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName());
return "Hyuni Kim";
}).thenApply((data) -> {
System.out.println(Thread.currentThread().getName());
return "我的名字是" + data;
}).thenAccept((data) -> {
System.out.println(Thread.currentThread().getName());
System.out.println("結(jié)果：" + data);
});
future.join();
}上述代碼展示了CompletableFuture的一個關(guān)鍵方面：鏈?zhǔn)讲僮鳌Ｍㄟ^CompletableFuture.supplyAsync()，首先創(chuàng)建并運行一個返回字符串結(jié)果的CompletableFuture。thenApply()接受前一個任務(wù)的結(jié)果，并執(zhí)行其他操作，本例中是添加一個字符串。最后，thenAccept()打印生成的數(shù)據(jù)。結(jié)果如下所示：
ForkJoinPool.commonPool-worker-1
ForkJoinPool.commonPool-worker-1
ForkJoinPool.commonPool-worker-1
Result: My name is Hyuni Kim有3個任務(wù)沒有在主線程中運行，這表明它們與主邏輯并行運行。當(dāng)您有具有結(jié)果并需要鏈接的任務(wù)時，CompletableFuture將是一個很好的選擇。
6. 總結(jié)
多線程是一種強大的工具，可以幫助開發(fā)人員優(yōu)化性能、提升用戶體驗、增強并發(fā)處理能力，并充分利用計算機的資源。
