面試官：什么是多線程中的上下文切換？
作者：Venus哥
線程池可以復用線程，避免頻繁創建和銷毀線程，從而減少上下文切換開銷。線程池中的線程會被重新分配任務，避免重復的上下文切換。
在多線程編程中，“上下文切換”指的是操作系統在不同線程之間切換執行時保存和恢復線程狀態的過程。每個線程都包含一個“上下文”，即當前執行的狀態信息，包括寄存器的值、程序計數器（指令位置）、堆棧指針等。
步驟：
- 保存當前線程的狀態：當一個線程被掛起時，操作系統會將該線程的寄存器、程序計數器等狀態信息保存到內存中，以便將來能夠恢復。
- 恢復新線程的狀態：接下來，操作系統加載即將運行的線程的狀態信息，使得該線程能夠從中斷的位置繼續執行。
- 切換到新線程執行：完成狀態的保存和恢復后，CPU就會開始執行新線程的指令。
開銷：
雖然上下文切換使得多個線程能夠共享CPU資源，但它并非完全沒有成本。保存和恢復狀態需要時間，頻繁的上下文切換會導致：
- 性能下降：頻繁切換會占用大量的CPU時間，導致真正執行任務的時間減少。
- 緩存失效：每次切換線程時，CPU緩存可能會被刷新，導致緩存效率降低，增加內存訪問延遲。
如何減少上下文切換策略？
- 減少線程數量：
每個線程都需要上下文切換資源，線程越多，切換頻率越高。如果任務量不大，減少線程數量可以降低上下文切換的頻率。
import java.util.List;
import java.util.Arrays;
public class ReduceThreadsExample {
public static void main(String[] args) {
List<String> tasks = Arrays.asList("task1", "task2", "task3", /* ... */ "task100");
int threadCount = 10;
int taskPerThread = tasks.size() / threadCount;
for (int i = 0; i < threadCount; i++) {
final int start = i * taskPerThread;
final int end = (i == threadCount - 1) ? tasks.size() : (i + 1) * taskPerThread;
new Thread(() -> {
for (int j = start; j < end; j++) {
System.out.println("Processing " + tasks.get(j));
}
}).start();
}
}
}- 使用多線程池：
線程池可以復用線程，避免頻繁創建和銷毀線程，從而減少上下文切換開銷。線程池中的線程會被重新分配任務，避免重復的上下文切換。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100; i++) {
int task = i;
executor.submit(() -> System.out.println("Processing task " + task));
}
executor.shutdown();
}
}- 增加任務的批處理：
盡量將多個小任務合并為一個批處理任務，減少線程之間的切換。這樣可以在同一個線程中連續完成多個任務，降低切換的頻率。
import java.util.List;
import java.util.Arrays;
public class BatchProcessingExample {
public static void main(String[] args) {
List<String> tasks = Arrays.asList("task1", "task2", "task3", /* ... */ "task100");
int batchSize = 10;
for (int i = 0; i < tasks.size(); i += batchSize) {
final List<String> batch = tasks.subList(i, Math.min(i + batchSize, tasks.size()));
new Thread(() -> {
for (String task : batch) {
System.out.println("Processing " + task);
}
}).start();
}
}
}- 盡量減少鎖競爭：
當多個線程競爭同一個鎖時，線程會頻繁等待和喚醒，導致頻繁的上下文切換。可以通過優化鎖的使用，或者采用更細粒度的鎖來減少鎖的競爭。例如，使用讀寫鎖來避免多個讀取線程間的競爭。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockCompetitionExample {
private static int counter = 0;
private static Lock lock = new ReentrantLock();
public static void main(String[] args) {
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
increment();
}
};
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Counter: " + counter);
}
private static void increment() {
lock.lock();
try {
counter++;
} finally {
lock.unlock();
}
}
}- 無鎖編程：
在適用的場景下，使用無鎖編程（如原子操作或CAS操作）來實現線程間的同步，避免因為鎖競爭而產生的上下文切換。這通常適用于輕量級的并發操作。
import java.util.concurrent.atomic.AtomicInteger;
public class LockFreeExample {
private static AtomicInteger counter = new AtomicInteger(0);
public static void main(String[] args) {
Runnable task = () -> {
for (int i = 0; i < 1000; i++) {
counter.incrementAndGet();
}
};
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Counter: " + counter.get());
}
}- 使用協程替代多線程：
協程是一種輕量級的“線程”實現，可以在一個線程中實現多任務的協作切換。由于協程的切換是由程序控制的，不需要操作系統參與，因此可以大幅減少上下文切換的開銷。JDK21后支持協程。
public class VirtualThreadExample {
public static void main(String[] args) {
try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 100; i++) {
int taskNumber = i;
executor.submit(() -> {
System.out.println("Processing task " + taskNumber + " in " + Thread.currentThread());
// 模擬一些I/O操作或其他阻塞任務
try {
Thread.sleep(1000); // 模擬任務執行時間
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return taskNumber;
});
}
} // 自動關閉 executor，確保所有虛擬線程完成執行
}
}責任編輯：武曉燕
來源：
架構殿堂
