java多執行緒是java面試中的高頻問題，如何才能在面試中脫穎而出呢？熟讀這裡的一百個java多執行緒面試問題即可。
回答：
回答： 有兩種方式可以建立執行緒：繼承Thread類或實現Runnable介面。
程式碼範例：
// 通過繼承Thread類
class MyThread extends Thread {
public void run() {
System.out.println("Thread is running");
}
}
MyThread thread = new MyThread();
thread.start();
// 通過實現Runnable介面
class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable is running");
}
}
Thread thread = new Thread(new MyRunnable());
thread.start();
回答：
sleep() 方法是Thread類的靜態方法，使當前執行緒暫停執行一段時間。在此期間，執行緒不會釋放物件鎖。wait() 方法是Object類的方法，使當前執行緒等待，直到其他執行緒呼叫相同物件的notify() 或 notifyAll() 方法來喚醒它。在等待期間，執行緒會釋放物件鎖。回答： 執行緒安全指多個執行緒存取共用資源時不會導致資料不一致或錯誤的狀態。實現執行緒安全的方法包括：
synchronized關鍵字來保護共用資源的存取。ReentrantLock顯示鎖實現同步。ConcurrentHashMap。回答： 死鎖是多個執行緒相互等待彼此持有的資源，導致所有執行緒無法繼續執行的情況。為避免死鎖，可以採取以下策略：
tryLock() 來避免一直等待鎖，設定超時時間。ExecutorService 執行緒池來控制執行緒數量。回答： 執行緒池是一組預先建立的執行緒，用於執行多個任務，以減少執行緒建立和銷燬的開銷。可以使用java.util.concurrent.Executors 類來建立執行緒池。
程式碼範例：
ExecutorService executor = Executors.newFixedThreadPool(5);
回答： Runnable 和 Callable 都是用於多執行緒程式設計的介面。主要區別在於：
Runnable 介面的 run() 方法沒有返回值，也不能丟擲異常。Callable 介面的 call() 方法可以返回值，並且可以丟擲異常。程式碼範例：
// Runnable 範例
class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable is running");
}
}
// Callable 範例
class MyCallable implements Callable<Integer> {
public Integer call() throws Exception {
return 42;
}
}
回答： volatile 關鍵字用於修飾變數，保證多個執行緒對該變數的操作是可見的，即一個執行緒對變數的修改會立即反映到其他執行緒中。它不提供原子性操作，只解決可見性問題。
程式碼範例：
class SharedResource {
private volatile boolean flag = false;
public void toggleFlag() {
flag = !flag;
}
public boolean isFlag() {
return flag;
}
}
回答： 同步機制用於保護共用資源免受多執行緒的並行存取。Java中的主要同步機制包括synchronized關鍵字和ReentrantLock顯示鎖。
程式碼範例：
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}
回答： CAS（Compare and Swap）是一種無鎖並行演演算法，通過比較記憶體中的值和期望值是否相等來判斷是否進行更新。它避免了鎖的使用，從而減少了執行緒競爭和上下文切換的開銷。
程式碼範例：
import java.util.concurrent.atomic.AtomicInteger;
public class CASExample {
private AtomicInteger counter = new AtomicInteger(0);
public void increment() {
counter.incrementAndGet();
}
public int getCount() {
return counter.get();
}
}
回答： 執行緒上下文切換是作業系統在多執行緒環境中，從一個執行緒切換到另一個執行緒的過程。它會帶來一定的開銷，因為需要儲存當前執行緒的狀態（暫存器、堆疊等）並載入另一個執行緒的狀態。過多的執行緒上下文切換會降低系統效能。
回答： 執行緒優先順序是一個整數值，用於指定執行緒排程的順序。Java中的執行緒優先順序範圍是1（最低優先順序）到10（最高優先順序）。可以使用setPriority(int priority)方法設定執行緒的優先順序。
程式碼範例：
Thread thread = new Thread();
thread.setPriority(Thread.MAX_PRIORITY); // 設定最高優先順序
回答： 守護執行緒是在後臺執行的執行緒，當所有的非守護執行緒結束時，守護執行緒會自動終止。可以使用setDaemon(true)方法將執行緒設定為守護執行緒。
程式碼範例：
Thread daemonThread = new Thread();
daemonThread.setDaemon(true); // 設定為守護執行緒
回答： 一般不推薦直接停止執行緒，因為這可能導致資源洩露或不穩定的狀態。推薦的方式是通過設定標誌位，讓執行緒自行退出迴圈或執行。stop()方法已被廢棄，因為它可能導致執行緒不釋放鎖等問題。
回答： 執行緒組是一種用於組織執行緒的機制，但在現代Java多執行緒程式設計中，不推薦使用執行緒組，因為更高階的機制如執行緒池可以更好地管理執行緒，而執行緒組的功能相對有限。
回答： 讀寫鎖允許多個執行緒同時讀取共用資源，但只允許一個執行緒寫入。這可以提高讀多寫少場景下的並行效能，因為多個讀操作可以並行執行，而寫操作需要獨佔存取。
程式碼範例：
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ReadWriteLockExample {
private ReadWriteLock lock = new ReentrantReadWriteLock();
private int data;
public int readData() {
lock.readLock().lock();
try {
return data;
} finally {
lock.readLock().unlock();
}
}
public void writeData(int value) {
lock.writeLock().lock();
try {
data = value;
} finally {
lock.writeLock().unlock();
}
}
}
回答： 執行緒間通訊是指多個執行緒之間交換資訊或共用資料的過程。可以使用wait()、notify()和notifyAll()方法來實現執行緒間通訊，也可以使用並行容器或其他同步機制。
回答： Java中提供了許多並行容器，用於在多執行緒環境中安全地運算元據，如ConcurrentHashMap、CopyOnWriteArrayList、BlockingQueue等。
回答： 執行緒區域性變數是一種特殊的變數，每個執行緒都有自己的獨立副本，不同執行緒之間互不影響。它適用於需要在多個執行緒間隔離資料的情況。
程式碼範例：
ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);
threadLocal.set(42); // 在當前執行緒中設定值
int value = threadLocal.get(); // 在當前執行緒中獲取值
回答：
回答： 執行緒間競爭條件是指多個執行緒並行存取共用資源，導致結果的順序或值不符合預期。可以通過同步機制（如synchronized、ReentrantLock）來避免競爭條件，確保只有一個執行緒存取資源。
回答： 執行緒的活躍性問題是指阻止執行緒正常執行的情況。主要型別包括死鎖、活鎖和飢餓。死鎖是多個執行緒相互等待資源，活鎖是執行緒不斷改變狀態以避免死鎖，但仍無法正常執行。飢餓是指某些執行緒一直無法獲得所需的資源。
回答： 不可變物件是一旦建立就不能被修改的物件。因為不可變物件的狀態不會發生變化，所以多個執行緒可以同時存取它而不需要額外的同步機制，從而提供了執行緒安全性。
回答： 原子操作是指在多執行緒環境中不可被中斷的操作，要麼全部執行，要麼不執行。Java提供了一些原子類（如AtomicInteger、AtomicLong）和原子方法，用於實現執行緒安全的自增、自減等操作。
程式碼範例：
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicExample {
private AtomicInteger counter = new AtomicInteger(0);
public void increment() {
counter.incrementAndGet();
}
public int getCount() {
return counter.get();
}
}
回答： 執行緒的上下文資料共用是一種線上程內部儲存資料的機制，使每個執行緒都有自己的資料副本。這可以避免執行緒之間的資料衝突，並提高效能。Java中的ThreadLocal類用於實現執行緒的上下文資料共用。
回答： 線上程池中，如果一個執行緒丟擲異常而未捕獲，執行緒將被終止，但執行緒池中的其他執行緒仍將繼續執行。可以通過在任務中捕獲異常來防止執行緒池中的異常影響其他執行緒。
程式碼範例：
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.execute(() -> {
try {
// 任務程式碼
} catch (Exception e) {
// 處理異常
}
});
回答： 進行執行緒偵錯和分析時，可以使用工具如VisualVM、jconsole、jstack等。這些工具可以幫助您檢視執行緒狀態、堆疊資訊、記憶體使用情況等，從而定位和解決執行緒相關的問題。
回答：
回答： 執行緒的上下文切換是指作業系統將當前執行緒的狀態儲存起來，然後切換到另一個執行緒的狀態的過程。這會帶來一定的開銷，包括儲存和恢復暫存器、堆疊等，可能會影響系統效能。
回答： 執行緒的執行順序保證是指程式在多執行緒環境下，保證特定操作的執行順序，如volatile、synchronized等機制可以確保特定的指令順序。
回答：
回答： 可以使用wait()、notify() 和 notifyAll() 方法來實現執行緒間的共同作業。這些方法用於在不同執行緒之間等待和通知。
程式碼範例：
class SharedResource {
private boolean flag = false;
public synchronized void waitForFlag() throws InterruptedException {
while (!flag) {
wait();
}
}
public synchronized void setFlag() {
flag = true;
notifyAll();
}
}
回答： 執行緒的上下文環境是指一個執行緒在執行時的狀態和資料，包括暫存器內容、堆疊資訊、執行緒區域性變數等。上下文切換是指從一個執行緒的上下文環境切換到另一個執行緒的過程。
回答： 執行緒的優化和調優是指通過合理的設計、同步機制、執行緒池設定等方式來提高多執行緒程式的效能和穩定性。優化包括減少執行緒上下文切換、減少鎖競爭、避免死鎖等。
回答： 使用執行緒池可以避免頻繁建立和銷燬執行緒的開銷，提高系統效能和資源利用率。執行緒池可以管理執行緒數量，重用執行緒，控制執行緒的執行順序，同時也可以避免執行緒數量過多導致系統資源耗盡的問題。
回答： 鎖粒度是指鎖定共用資源的範圍。選擇適當的鎖粒度是為了在保證執行緒安全的同時，最大程度地減少鎖競爭的情況。通常，鎖的粒度越小，效率越高，但維護成本可能會增加。
回答： ABA問題是指一個值在多執行緒環境下先被修改為其他值，然後又被修改回原始值的情況，導致檢測值是否發生變化時出現誤判。可以通過使用帶有版本號的變數或使用AtomicStampedReference來避免ABA問題。
回答：
回答： 可重入性是指一個執行緒在持有某個鎖時，可以繼續獲取同一個鎖而不會被阻塞。重入鎖是可重入的，因為它記錄了持有鎖的執行緒以及獲取次數，執行緒在持有鎖的情況下可以多次獲取該鎖。
回答： 在多執行緒環境中，執行緒的異常不能直接傳遞到其他執行緒。可以線上程的任務中捕獲異常，然後通過回撥、共用變數等方式傳遞異常資訊給其他執行緒進行處理。
回答： 活動物件模式是一種並行設計模式，用於將方法呼叫和方法執行解耦，使方法呼叫變為非同步。它將方法呼叫封裝成任務，並由一個專門的執行緒執行，從而避免了呼叫者執行緒的阻塞。
回答： 閉鎖是一種同步輔助類，用於等待多個執行緒執行完畢後再繼續執行。它通過一個初始計數值和countDown()方法來實現等待。
程式碼範例：
import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3);
Runnable task = () -> {
// 執行任務
latch.countDown();
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
Thread thread3 = new Thread(task);
thread1.start();
thread2.start();
thread3.start();
latch.await(); // 等待所有執行緒執行完畢
System.out.println("All threads have finished.");
}
}
回答： 號誌是一種同步工具，用於控制同時存取某個資源的執行緒數量。它通過維護一個許可證數量來實現。
程式碼範例：
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
public static void main(String[] args) throws InterruptedException {
Semaphore semaphore = new Semaphore(2); // 允許2個執行緒同時存取
Runnable task = () -> {
try {
semaphore.acquire(); // 獲取許可證
// 執行任務
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release(); // 釋放許可證
}
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
Thread thread3 = new Thread(task);
thread1.start();
thread2.start();
thread3.start();
}
}
回答： 柵欄是一種同步輔助類，用於等待多個執行緒達到一個共同的屏障點，然後再繼續執行。它通過指定等待的執行緒數量和await()方法來實現。
程式碼範例：
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierExample {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
System.out.println("All threads have reached the barrier.");
});
Runnable task = () -> {
try {
// 執行任務
barrier.await(); // 等待其他執行緒
} catch (Exception e) {
e.printStackTrace();
}
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
Thread thread3 = new Thread(task);
thread1.start();
thread2.start();
thread3.start();
}
}
回答： 可以使用CountDownLatch、CyclicBarrier或其他同步機制來確保執行緒的有序執行和輸出。
程式碼範例：
import java.util.concurrent.CountDownLatch;
public class OrderedOutputExample {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(2);
Runnable task = () -> {
// 執行任務
latch.countDown();
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
thread1.start();
thread2.start();
latch.await(); // 等待執行緒1和執行緒2執行完畢
System.out.println("Thread 1 and Thread 2 have finished.");
// 執行下一個任務
}
}
回答： 執行緒的優雅終止是指線上程需要結束時，通過合適的方式終止執行緒的執行，確保資源的釋放和狀態的清理。
回答： 可以使用雙重檢查鎖定、靜態內部類等方式實現執行緒安全的單例模式。
程式碼範例：
public class Singleton {
private volatile static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
回答： 可以使用同步機制（如synchronized、ReentrantLock）來保護共用資源的存取，避免多個執行緒同時修改資源導致的競爭問題。
回答： 任務分解模式是一種並行設計模式，用於將一個大任務拆分成多個小任務，然後將小任務分配給多個執行緒並行執行，最終將結果合併。
回答： 執行緒安全的內部類是指
在類的內部定義一個私有靜態內部類，該內部類持有一個外部類的範例，並在靜態初始化時建立範例。這樣可以保證懶載入的同時實現執行緒安全。
程式碼範例：
public class Singleton {
private Singleton() {}
private static class Holder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return Holder.INSTANCE;
}
}
回答： 工作竊取演演算法是一種用於任務排程的演演算法，通常在基於任務的並行程式設計中使用。它允許空閒執行緒從其他執行緒的任務佇列中竊取任務來執行，以充分利用多核處理器。
回答： ThreadLocalRandom是Java 7引入的一個類，用於在多執行緒環境下生成亂數，它比Random類更適合高並行環境。
程式碼範例：
import java.util.concurrent.ThreadLocalRandom;
public class RandomExample {
public static void main(String[] args) {
ThreadLocalRandom random = ThreadLocalRandom.current();
int randomNumber = random.nextInt(1, 101); // 生成1到100的隨機整數
System.out.println(randomNumber);
}
}
回答： Amdahl's Law是一種用於衡量並行性效果的公式。它表達了在系統中引入並行性後，加速比的上限。它告訴我們，如果某部分程式是序列的，那麼無論如何增加處理器數量，整體加速比仍然受限於序列部分的影響。
回答： 執行緒的可見性問題是指當一個執行緒修改了共用變數的值，其他執行緒可能無法立即看到這個變化。可以使用volatile關鍵字、synchronized關鍵字、Atomic類等方式來解決可見性問題。
回答： ForkJoinPool是Java 7引入的一個執行緒池，專門用於執行任務分解模式。可以使用ForkJoinTask和RecursiveTask來實現任務的分解和執行。
程式碼範例：
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
public class ForkJoinExample extends RecursiveTask<Integer> {
private final int threshold = 10;
private int[] array;
private int start;
private int end;
public ForkJoinExample(int[] array, int start, int end) {
this.array = array;
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
if (end - start <= threshold) {
// 執行任務
int sum = 0;
for (int i = start; i < end; i++) {
sum += array[i];
}
return sum;
} else {
int middle = (start + end) / 2;
ForkJoinExample leftTask = new ForkJoinExample(array, start, middle);
ForkJoinExample rightTask = new ForkJoinExample(array, middle, end);
leftTask.fork();
rightTask.fork();
return leftTask.join() + rightTask.join();
}
}
public static void main(String[] args) {
int[] array = new int[1000];
for (int i = 0; i < array.length; i++) {
array[i] = i + 1;
}
ForkJoinPool pool = ForkJoinPool.commonPool();
int result = pool.invoke(new ForkJoinExample(array, 0, array.length));
System.out.println("Sum: " + result);
}
}
回答： 阻塞佇列是一種執行緒安全的佇列，提供了阻塞操作，如在佇列為空時等待元素的新增，或在佇列滿時等待元素的移除。可以使用阻塞佇列實現生產者-消費者模式。
程式碼範例：
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ProducerConsumerExample {
public static void main(String[] args) {
BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
Runnable producer = () -> {
try {
for (int i = 1; i <= 20; i++) {
queue.put(i);
System.out.println("Produced: " + i);
Thread.sleep(200);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Runnable consumer = () -> {
try {
for (int i = 1; i <= 20; i++) {
int value = queue.take();
System.out.println("Consumed: " + value);
Thread.sleep(400);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Thread producerThread = new Thread(producer);
Thread consumerThread = new Thread(consumer);
producerThread.start();
consumerThread.start();
}
}
回答： Thread.interrupt()方法用於中斷執行緒。可以在需要中斷執行緒的地方呼叫該方法，然後線上程的任務中通過Thread.isInterrupted()來檢查中斷狀態並採取相應的操作。
程式碼範例：
Thread thread = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
// 執行任務
}
});
thread.start();
// 在需要中斷執行緒的地方呼叫
thread.interrupt();
回答： StampedLock是Java並行包中引入的一種鎖機制，支援讀寫鎖和樂觀讀鎖。可以使用tryOptimisticRead()方法獲取樂觀讀鎖，然
後通過validate()方法來驗證讀鎖是否有效。
程式碼範例：
import java.util.concurrent.locks.StampedLock;
public class StampedLockExample {
private double x, y;
private final StampedLock lock = new StampedLock();
void move(double deltaX, double deltaY) {
long stamp = lock.writeLock();
try {
x += deltaX;
y += deltaY;
} finally {
lock.unlockWrite(stamp);
}
}
double distanceFromOrigin() {
long stamp = lock.tryOptimisticRead();
double currentX = x;
double currentY = y;
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
currentX = x;
currentY = y;
} finally {
lock.unlockRead(stamp);
}
}
return Math.sqrt(currentX * currentX + currentY * currentY);
}
}
回答： Exchanger是Java並行包中的一個同步工具，用於實現兩個執行緒間的資料交換。它通過exchange()方法來交換資料，並在交換完成後繼續執行。
程式碼範例：
import java.util.concurrent.Exchanger;
public class ExchangerExample {
public static void main(String[] args) {
Exchanger<String> exchanger = new Exchanger<>();
Runnable task1 = () -> {
try {
String data = "Hello from Thread 1";
System.out.println("Thread 1 sending: " + data);
String receivedData = exchanger.exchange(data);
System.out.println("Thread 1 received: " + receivedData);
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Runnable task2 = () -> {
try {
String data = "Hello from Thread 2";
System.out.println("Thread 2 sending: " + data);
String receivedData = exchanger.exchange(data);
System.out.println("Thread 2 received: " + receivedData);
} catch (InterruptedException e) {
e.printStackTrace();
}
};
Thread thread1 = new Thread(task1);
Thread thread2 = new Thread(task2);
thread1.start();
thread2.start();
}
}
回答： 執行緒的優先順序是一個整數，用於指定執行緒在排程時的優先順序順序。可以使用setPriority()方法來設定執行緒的優先順序。
程式碼範例：
Thread thread1 = new Thread(() -> {
// 任務程式碼
});
thread1.setPriority(Thread.MAX_PRIORITY); // 設定最高優先順序
Thread thread2 = new Thread(() -> {
// 任務程式碼
});
thread2.setPriority(Thread.MIN_PRIORITY); // 設定最低優先順序
回答： CopyOnWrite容器是Java並行包中的一種執行緒安全容器，它在修改時建立一個新的副本，從而避免了修改和讀取的競爭。它在讀多寫少的場景下比較適用，因為寫操作會導致複製整個容器，開銷較大。
回答： 執行緒堆疊溢位是指執行緒的呼叫棧空間不足以容納方法呼叫所需的資訊，導致棧溢位錯誤。可以通過調整虛擬機器器的棧大小、優化遞迴方法或者減少方法呼叫深度來避免。
回答： 記憶體一致性問題是指多執行緒環境下，由於記憶體讀寫操作的不同步，導致共用變數的值在不同執行緒之間看起來是不一致的。使用volatile關鍵字可以確保在寫入一個volatile變數時，會將變數的值重新整理到主記憶體，並在讀取volatile變數時，會從主記憶體中讀取最新值。
回答： ThreadGroup是一個執行緒組，用於將多個執行緒組織在一起，方便管理。它可以用來設定執行緒組的優先順序、設定執行緒組的非捕獲例外處理器等。
回答： 執行緒池的拒絕策略是指線上程池無法繼續接受新任務時，如何處理新提交的任務。常見的拒絕策略有：AbortPolicy（預設，丟擲異常）、CallerRunsPolicy（使用呼叫執行緒執行任務）、DiscardPolicy（直接丟棄任務）和DiscardOldestPolicy（丟棄佇列中最老的任務）。
可以通過實現RejectedExecutionHandler介面來自定義拒絕策略。
程式碼範例：
import java.util.concurrent.*;
public class CustomThreadPoolExample {
public static void main(String[] args) {
RejectedExecutionHandler customHandler = (r, executor) -> {
System.out.println("Custom rejected: " + r.toString());
};
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // corePoolSize
5, // maximumPoolSize
1, TimeUnit.SECONDS, // keepAliveTime and unit
new LinkedBlockingQueue<>(10), // workQueue
customHandler // rejectedExecutionHandler
);
for (int i = 1; i <= 10; i++) {
final int taskNum = i;
executor.execute(() -> {
System.out.println("Executing task " + taskNum);
});
}
executor.shutdown();
}
}
回答： 可以使用ScheduledExecutorService介面來在多執行緒環境下實現定時任務。通過schedule()方法可以安排任務在固定延遲或固定週期執行。
程式碼範例：
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledTaskExample {
public static void main(String[] args) {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
Runnable task = () -> {
System.out.println("Task executed at: " + System.currentTimeMillis());
};
// 延遲3秒後執行
executor.schedule(task, 3, TimeUnit.SECONDS);
// 初始延遲1秒，然後每隔2秒執行一次
executor.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);
// 初始延遲1秒，然後等待上一個任務完成後再延遲2秒執行
executor.scheduleWithFixedDelay(task, 1, 2, TimeUnit.SECONDS);
}
}
回答： 可以通過捕獲InterruptedException異常並在例外處理中繼續執行任務，以達到不可中斷的效果。
程式碼範例：
Thread thread = new Thread(() -> {
try {
while (!Thread.currentThread().isInterrupted()) {
// 執行不可中斷的任務
}
} catch (InterruptedException e) {
// 捕獲異常並繼續執行任務
Thread.currentThread().interrupt();
}
});
thread.start();
// 在需要中斷執行緒的地方呼叫
thread.interrupt();
回答： Phaser是Java並行包中的一個同步工具，可以用於多階段並行任務的同步。它可以分階段同步執行緒的執行，當每個階段的任務都完成時，執行緒才能
繼續執行下一個階段。
程式碼範例：
import java.util.concurrent.Phaser;
public class PhaserExample {
public static void main(String[] args) {
Phaser phaser = new Phaser(3); // 需要同步的執行緒數
Runnable task = () -> {
// 執行任務
phaser.arriveAndAwaitAdvance(); // 等待其他執行緒到達
};
Thread thread1 = new Thread(task);
Thread thread2 = new Thread(task);
Thread thread3 = new Thread(task);
thread1.start();
thread2.start();
thread3.start();
phaser.arriveAndAwaitAdvance(); // 等待所有執行緒完成第一階段任務
// 執行下一個階段任務
}
}
回答： 執行緒安全性是指在多執行緒環境下，對共用資源的存取和修改不會導致資料不一致或產生競態條件。可以通過以下幾個標準來評估一個類是否是執行緒安全的：
原子性（Atomicity）： 方法的執行必須是原子的，要麼全部執行完成，要麼不執行。
可見性（Visibility）： 修改後的值對其他執行緒必須是可見的，即讀取到最新值。
有序性（Ordering）： 程式執行的順序必須與程式碼的順序一致。
如果一個類滿足以上三個條件，它就可以被認為是執行緒安全的。
回答： 非阻塞演演算法是指在多執行緒環境下，不使用傳統的鎖機制，而是使用原子操作等方法來實現對共用資源的存取。它可以避免執行緒的阻塞和競爭，從而提高並行效能。
在使用非阻塞演演算法時，通常會使用原子變數、CAS操作、樂觀鎖等技術來實現執行緒安全的存取。然而，非阻塞演演算法也比較複雜，適用於特定場景，需要仔細的設計和測試。
回答： 鎖消除是指在編譯器優化階段，將無法被其他執行緒存取的鎖給消除掉，從而減少鎖的競爭。鎖膨脹是指在多執行緒環境下，鎖的競爭激烈時，將輕量級鎖升級為重量級鎖，以提供更強的同步保護。
可以通過減少鎖的作用範圍、使用區域性變數來避免鎖消除，以及優化鎖的粒度來避免鎖膨脹。
回答： 執行緒的上下文切換是指從一個執行緒切換到另一個執行緒的過程，作業系統需要儲存當前執行緒的上下文並載入下一個執行緒的上下文。上下文切換會消耗時間和資源，影響系統效能。
可以通過減少執行緒的數量、合理分配CPU時間片、使用無鎖程式設計、使用協程等方式來減少上下文切換的開銷。
回答： 執行緒洩漏是指在多執行緒程式中，某個執行緒被建立後沒有被正確關閉，導致該執行緒的資源無法被釋放，最終可能導致系統效能下降。可以通過合理地使用執行緒池、及時關閉執行緒、使用try-with-resources來避免執行緒洩漏。
回答： ThreadLocal是一個執行緒區域性變數，它提供了在每個執行緒中儲存資料的方式。常見的使用場景包括：
擁有自己的獨立副本，如資料庫連線、Session等。
優點包括：
執行緒安全：每個執行緒擁有自己的副本，不會出現競爭條件。
簡化引數傳遞：避免了在方法之間傳遞大量引數。
缺點包括：
記憶體漏失：如果不及時清理ThreadLocal中的資料，可能會導致記憶體漏失。
可能增加上下文切換：當執行緒數過多時，ThreadLocal可能會增加上下文切換的開銷。
回答： 守護執行緒是一種在後臺執行的執行緒，當所有非守護執行緒結束後，守護執行緒會隨著JVM的退出而結束。可以通過呼叫setDaemon(true)方法將執行緒設定為守護執行緒。
程式碼範例：
Thread daemonThread = new Thread(() -> {
while (true) {
// 執行後臺任務
}
});
daemonThread.setDaemon(true);
daemonThread.start();
回答： CAS（Compare and Swap）操作是一種原子操作，用於實現無鎖同步。它在多執行緒環境下用於解決並行存取共用資源的問題，通過比較記憶體中的值與期望值是否相等，如果相等則將新值寫入記憶體，從而保證原子性。
CAS操作通常由CPU提供的指令實現，例如AtomicInteger、AtomicLong等。
程式碼範例：
import java.util.concurrent.atomic.AtomicInteger;
public class CASExample {
private static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
count.incrementAndGet();
}
}).start();
}
// 等待所有執行緒執行完成
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Count: " + count);
}
}
回答： 死鎖是指多個執行緒因為互相等待對方釋放鎖而陷入無限等待的狀態。死鎖通常涉及多個資源和多個執行緒。
可以通過以下幾種方法來避免死鎖：
按照固定順序獲取鎖： 執行緒按照相同的順序獲取鎖，降低死鎖的概率。
設定超時時間： 如果執行緒無法獲取到鎖，可以設定一個超時時間，超時後釋放已經獲取的鎖。
使用tryLock()方法： 使用tryLock()方法來嘗試獲取鎖，如果無法獲取則放棄已經獲取的鎖。
使用Lock介面的tryLock()方法： 使用Lock介面的tryLock()方法來嘗試獲取多個鎖，如果無法獲取所有鎖，則釋放已經獲取的鎖。
回答： 執行緒排程演演算法是作業系統用於決定哪個執行緒在某一時刻執行的策略。常見的執行緒排程演演算法包括：
先來先服務（FCFS）： 按照執行緒的到達順序進行排程。
短作業優先（SJF）： 優先排程執行時間最短的執行緒。
優先順序排程： 按照執行緒的優先順序進行排程，高優先順序的執行緒會先執行。
時間片輪轉（Round Robin）： 每個執行緒分配一個時間片，在時間片內執行，然後切換到下一個執行緒。
多級反饋佇列（Multilevel Feedback Queue）： 根據執行緒的歷史行為調整優先順序，提高響應時間。
回答： 並行程式設計中存在以下風險和挑戰：
競態條件（Race Condition）： 多個執行緒競爭共用資源，導致資料不一致。
死鎖： 多個執行緒相互等待對方釋放鎖而陷入無限等待。
執行緒安全性問題： 多個執行緒同時存取共用資源，導致資料不一致。
記憶體一致性問題： 多個執行緒在不同的CPU快取中讀寫共用變數，導致資料不一致。
上下文切換開銷： 執行緒頻繁切換導致效能下降。
複雜性增加： 並行程式設計增加了程式碼的複雜性和偵錯難度。
為了應對這些風險和挑戰，需要合理地設計並行方案，使用適當的同步機制，進行充分的測試和調優。
回答： 執行緒的活躍性問題是指在多執行緒環境下，執行緒無法正常執行或無法繼續執行的問題。常見的執行緒活躍性問題包括：
死鎖： 多個執行緒相互等待對方釋放鎖。
活鎖： 多個執行緒反覆嘗試某個操作，但始終無法繼續執行。
飢餓： 某些執行緒無法獲取到資源，一直無法執行。
無限迴圈： 執行緒陷入無限迴圈，無法退出。
為了避免執行緒的活躍性問題，需要合理地設計同步機制，避免長時間佔用鎖，以及進行充分的測試和偵錯。
回答： ABA問題是一種在無鎖程式設計中出現的問題，指在多執行緒環境下，一個值先變成了A，然後變成了B，最後又變回了A，而執行緒可能無法察覺這個變化。這可能導致某些操作在判斷值相等時出現誤判。
AtomicStampedReference是Java並行包中提供的一種解決ABA問題的工具。它通過引入版本號（Stamp）來解決問題，即除了比較參照值外，還需要比較版本號是否匹配。
程式碼範例：
import java.util.concurrent.atomic.AtomicStampedReference;
public class ABAProblemSolution {
public static void main(String[] args) {
AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<>(1, 0);
int stamp = atomicStampedRef.getStamp(); // 獲取初始版本號
Thread thread1 = new Thread(() -> {
atomicStampedRef.compareAndSet(1, 2, stamp, stamp + 1); // A -> B
atomicStampedRef.compareAndSet(2, 1, stamp + 1, stamp + 2); // B -> A
});
Thread thread2 = new Thread(() -> {
int expectedStamp = atomicStampedRef.getStamp();
int expectedValue = atomicStampedRef.getReference();
try {
Thread.sleep(1000); // 等待執行緒1執行完成
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean success = atomicStampedRef.compareAndSet(expectedValue, 3, expectedStamp, expectedStamp + 1);
System.out.println("Thread 2 update: " + success);
});
thread1.start();
thread2.start();
}
}
回答： Fork-Join框架是Java並行包中的一個工具，用於實現任務的並行處理。它基於「分而治之」的思想，將大任務分割成小任務，然後並行處理小任務，最後合併結果。
使用Fork-Join框架，需要繼承RecursiveTask（有返回結果）或RecursiveAction（無返回結果），並實現compute()方法來處理任務。
程式碼範例：
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
public class ForkJoinExample {
static class SumTask extends RecursiveTask<Long> {
private final int[] array;
private final int start;
private final int end;
SumTask(int[] array, int start, int end) {
this.array = array;
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
if (end - start <= 100) { // 閾值，小於等於100個元素時直接計算
long sum = 0;
for (int i = start; i < end; i++) {
sum += array[i];
}
return sum;
} else { // 大於100個元素時分割任務
int middle = (start + end) / 2;
SumTask leftTask = new SumTask(array, start, middle);
SumTask rightTask = new SumTask(array, middle, end);
leftTask.fork();
rightTask.fork();
return leftTask.join() + rightTask.join();
}
}
}
public static void main(String[] args) {
ForkJoinPool forkJoinPool = new ForkJoinPool();
int[] array = new int[1000];
for (int i = 0; i < array.length; i++) {
array[i] = i + 1;
}
long result = forkJoinPool.invoke(new SumTask(array, 0, array.length));
System.out.println("Sum: " + result);
}
}
回答： 並行流是Java 8引入的一種特性，可以在多核處理器上並行處理流中的資料。並行流將資料分成多個部分，分別在多個執行緒上進行處理，從而提高處理速度。
使用並行流，只需將流物件通過parallel()方法轉換為並行流，然後進行流操作即可。
程式碼範例：
import java.util.Arrays;
import java.util.List;
public class ParallelStreamExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.parallelStream()
.filter(n -> n % 2 == 0) // 過濾偶數
.mapToInt(Integer::intValue) // 轉換為int型別
.sum();
System.out.println("Sum of even numbers: " + sum);
}
}
回答： 執行緒組（ThreadGroup）是Java中用於組織和管理執行緒的一種機制。執行緒組允許將執行緒劃分為多個組，方便管理和控制。執行緒組可以巢狀，形成一個樹狀結構。
執行緒組的主要作用包括：
設定執行緒組的優先順序。
設定執行緒組的非捕獲例外處理器。
批次中斷執行緒組中的所有執行緒。
方便統計和監控執行緒。
回答： 執行緒間的共同作業和通訊可以通過以下方式實現：
共用變數： 多個執行緒共用一個變數，通過鎖、號誌等同步機制來控制存取。
管道（Pipe）： 通過一個執行緒向管道寫入資料，另一個執行緒從管道讀取資料，實現執行緒間通訊。
阻塞佇列： 使用阻塞佇列作為共用資料結構，生產者執行緒往佇列中放資料，消費者執行緒從佇列中取資料。
條件變數（Condition）： 使用Condition物件實現執行緒間的等待和通知。
號誌（Semaphore）： 使用號誌來控制對共用資源的存取。
執行緒間的訊號： 使用wait()和notify()或notifyAll()來實現執行緒間的等待和通知。
回答： 執行緒池是一種管理和複用執行緒的機制，可以避免頻繁地建立和銷燬執行緒，從而提高程式的效能和資源利用率。Java中的執行緒池由Executor框架提供，主要有ThreadPoolExecutor實現。
可以通過Executors類提供的工廠方法來建立不同型別的執行緒池，如newFixedThreadPool()、newCachedThreadPool()和newScheduledThreadPool()等。
程式碼範例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
final int taskNum = i;
executor.execute(() -> {
System.out.println("Executing task " + taskNum);
});
}
executor.shutdown();
}
}
回答： 執行緒池的核心執行緒數是執行緒池中保持活動狀態的執行緒數量，最大執行緒數是執行緒池允許的最大執行緒數量。工作佇列是用來儲存等待執行的任務的佇列。
可以通過呼叫ThreadPoolExecutor的建構函式來建立自定義的執行緒池，並通過調整核心執行緒數、最大執行緒數和工作佇列的容量來調整執行緒池的效能和行為。
回答： 執行緒池的拒絕策略是線上程池無法繼續接受新任務時，決定如何處理新提交的任務。常見的拒絕策略有：
AbortPolicy（預設）： 丟擲RejectedExecutionException異常。
CallerRunsPolicy： 使用呼叫執行緒執行任務。
DiscardPolicy： 直接丟棄新提交的任務。
DiscardOldestPolicy： 丟棄佇列中最老的任務。
可以根據實際需求選擇合適的拒絕策略，或者實現自定義的拒絕策略。
回答： 執行緒池的預啟動策略是指線上程池建立後，提前建立一定數量的核心執行緒，並放入工作佇列中，以縮短任務執行的啟動時間。
可以通過呼叫prestartAllCoreThreads()方法來使用預啟動策略，它會建立所有核心執行緒並放入工作佇列中。
程式碼範例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class PrestartCoreThreadsExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(5);
((ThreadPoolExecutor) executor).prestartAllCoreThreads(); // 預啟動所有核心執行緒
for (int i = 0; i < 10; i++) {
final int taskNum = i;
executor.execute(() -> {
System.out.println("Executing task " + taskNum);
});
}
executor.shutdown();
}
}
回答： 在Fork-Join框架中，工作竊取是指某個執行緒從其他執行緒的佇列中偷取任務執行。當一個執行緒的佇列為空時，它可以從其他執行緒的佇列末尾偷取任務來執行，這可以提高執行緒的利用率和任務的分配均衡。
為了提高工作竊取的效率，可以將任務分成更小的子任務，以便更多的執行緒可以參與工作竊取。同時，可以避免過多地建立執行緒，以減少上下文切換的開銷。
回答： 樂觀鎖和悲觀鎖是兩種不同的並行控制策略。
樂觀鎖： 假設多個執行緒之間不會發生衝突，每個執行緒可以直接執行操作，但在更新時需要檢查資料是否被其他執行緒修改過。如果被修改過，則重新嘗試操作。
悲觀鎖： 假設多個執行緒之間會發生衝突，每個執行緒在操作前會獲取鎖，以防止其他執行緒同時修改資料。一旦執行緒獲得鎖，其他執行緒必須等待。
樂觀鎖通常使用版本號、時間戳等機制來實現，而悲觀鎖則使用鎖機制，如Java中的synchronized和ReentrantLock。
回答： CAS（Compare and Swap）操作的ABA問題是指，一個值先從A變為B，然後再變回A，而在操作過程中可能有其他執行緒對這個值進行了修改。
使用版本號可以解決CAS操作的ABA問題。在每次更新時，不僅需要比較值是否相等，還需要比較版本號是否匹配。這樣，即使值回到了A，但版本號已經發生了變化，其他執行緒仍可以正確識別出這種情況。
Java中的AtomicStampedReference可以用來解決ABA問題，它引入了版本號機制。
回答： 執行緒的上下文類載入器是執行緒在載入類時使用的類載入器。Java中的類載入器有父子關係，類載入器之間可以形成一棵樹狀結構，但是執行緒上下文類載入器不一定遵循父子關係，可以根據實際情況進行設定。
上下文類載入器在多執行緒環境中非常有用，特別是在一些框架中，例如執行緒池中的執行緒可能無法存取正確的類路徑。通過設定上下文類載入器，可以確保執行緒載入正確的類。
回答： Java記憶體模型（JMM）是一種規範，用於定義多執行緒程式中各個執行緒之間如何存取共用記憶體。JMM定義了各種操作的順序和可見性，以及如何防止出現不正確的重排序。
JMM通過使用同步鎖、volatile關鍵字、final關鍵字等來保證執行緒安全。同步鎖可以確保多個執行緒之間的互斥存取，volatile關鍵字可以確保變數的可見性和禁止重排序，而final關鍵字可以確保不會出現物件被修改的情況。
回答： 執行緒安全性是指在多執行緒環境下，對共用資源的存取和修改不會導致資料不一致或產生競態條件。可以通過以下幾個標準來評估一個類是否是執行緒安全的：
原子性（Atomicity）： 方法的執行必須是原子的，要麼全部執行完成，要麼不執行。
可見性（Visibility）： 修改後的值對其他執行緒必須是可見的，即讀取到最新值。
有序性（Ordering）： 程式執行的順序必須與程式碼的順序一致。
如果一個類滿足以上三個條件，它就可以被認為是執行緒安全的。
回答： 實現執行緒安全的單例模式可以使用以下幾種方式：
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
getInstance()方法時才會載入內部類，從而實現懶載入。public class Singleton {
private Singleton() {}
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
public enum Singleton {
INSTANCE;
// 可以新增其他方法和屬性
}
這些方法都可以實現執行緒安全的單例模式，根據實際需求選擇合適的方法。
回答： 執行緒安全集合是多執行緒環境下可以安全操作的資料結構，可以確保在並行存取時不會出現資料不一致或競態條件。一些常見的執行緒安全集合類包括：
ConcurrentHashMap： 執行緒安全的雜湊表，用於替代HashMap。
CopyOnWriteArrayList： 執行緒安全的動態陣列，適用於讀多寫少的場景。
CopyOnWriteArraySet： 基於CopyOnWriteArrayList實現的執行緒安全的集合。
ConcurrentLinkedQueue： 執行緒安全的無界非阻塞佇列。
BlockingQueue： 一系列阻塞佇列，如ArrayBlockingQueue、LinkedBlockingQueue等。
ConcurrentSkipListMap： 執行緒安全的跳錶實現的有序對映。
這些執行緒安全集合類在多執行緒環境下可以安全地進行操作，不需要額外的同步措施。
回答： 執行緒安全性檢查工具是一類用於檢查並行程式中執行緒安全問題的工具，可以幫助發現和修復潛在的並行bug。常見的執行緒安全性檢查工具包括：
FindBugs/SpotBugs： 靜態程式碼分析工具，可以檢查程式碼中的並行問題。
CheckThread： 可以用於檢查多執行緒程式中是否存線上程安全問題。
ThreadSanitizer（TSan）： 一種記憶體錯誤檢測工具，可以檢測多執行緒程式中的資料競爭和死鎖問題。
Java Concurrency Stress Test (jcstress)： Java官方提供的測試工具，用於檢測並行程式碼中的不確定行為。
這些工具可以在開發和測試階段幫助發現並行問題，從而提高並行程式的質量。
回答： 執行緒Dump是當前JVM中所有執行緒的狀態快照，Heap Dump是當前JVM堆記憶體的快照。它們可以幫助開發者分析程式的執行狀態和記憶體使用情況，尤其在出現死鎖、記憶體漏失等問題時非常有用。
生成執行緒Dump和Heap Dump的方式有多種，包括使用JVM自帶的jstack命令、jmap命令，或者在程式碼中使用ThreadMXBean和MemoryMXBean進行動態獲取。分析這些資訊可以使用工具如Eclipse Memory Analyzer（MAT）等。
回答： 處理並行效能問題需要綜合考慮多個方面，包括程式碼設計、同步機制、並行控制等。一些常見的處理方法包括：
避免過多的鎖競爭： 減小鎖的粒度，儘量使用無鎖資料結構。
減少上下文切換： 使用執行緒池、協程等機制，減少執行緒頻繁建立和銷燬。
合理分割任務： 使用Fork-Join框架等技術將大任務拆分成小任務，提高並行度。
使用高效能的資料結構： 選擇合適的資料結構，如ConcurrentHashMap、ConcurrentSkipList等。
合理調整執行緒池引數： 根據實際需求調整執行緒池的核心執行緒數、最大執行緒數和工作佇列大小。
進行效能測試和調優： 使用效能測試工具進行壓力測試，根據測試結果進行效能調優。
處理並行效能問題需要綜合考慮多個因素，根據具體情況進行優化和調整。