java并發編程的基礎

# Java并發編程的基礎

## 引言

在當今多核處理器普及的時代，并發編程已成為提高程序性能的關鍵手段。Java作為一門成熟的企業級編程語言，提供了豐富的并發編程工具和API。本文將系統介紹Java并發編程的基礎知識，包括線程基礎、線程安全、同步機制以及常用并發工具類等內容。

## 一、線程基礎

### 1.1 線程與進程

- **進程**：操作系統資源分配的基本單位，擁有獨立的內存空間
- **線程**：CPU調度的基本單位，共享進程內存空間
- **關系**：一個進程包含多個線程，線程是輕量級的進程

### 1.2 線程創建方式

```java
// 方式1：繼承Thread類
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}

// 方式2：實現Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}

// 方式3：使用Lambda表達式
Thread lambdaThread = new Thread(() -> {
    System.out.println("Lambda thread running");
});

1.3 線程生命周期

1. NEW：新建狀態
2. RUNNABLE：可運行狀態
3. BLOCKED：阻塞狀態
4. WTING：等待狀態
5. TIMED_WTING：定時等待狀態
6. TERMINATED：終止狀態

二、線程安全與同步

2.1 線程安全問題

當多個線程訪問共享資源時，可能導致數據不一致的問題，典型場景包括： - 競態條件（Race Condition） - 內存可見性問題 - 指令重排序問題

2.2 synchronized關鍵字

// 同步方法
public synchronized void syncMethod() {
    // 臨界區代碼
}

// 同步代碼塊
public void syncBlock() {
    synchronized(this) {
        // 臨界區代碼
    }
}

// 靜態方法同步
public static synchronized void staticSync() {
    // 臨界區代碼
}

2.3 volatile關鍵字

保證變量的可見性和禁止指令重排序：

private volatile boolean flag = false;

2.4 鎖機制比較

三、Java并發工具類

3.1 CountDownLatch

// 初始化計數器
CountDownLatch latch = new CountDownLatch(3);

// 工作線程
new Thread(() -> {
    // 執行任務
    latch.countDown();
}).start();

// 主線程等待
latch.await();
System.out.println("所有任務完成");

3.2 CyclicBarrier

CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("所有線程到達屏障");
});

for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        try {
            System.out.println("線程到達");
            barrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }).start();
}

3.3 Semaphore

Semaphore semaphore = new Semaphore(3); // 允許3個線程同時訪問

new Thread(() -> {
    try {
        semaphore.acquire();
        // 訪問資源
    } finally {
        semaphore.release();
    }
}).start();

四、線程池

4.1 線程池優勢

1. 降低資源消耗
2. 提高響應速度
3. 提高線程可管理性
4. 提供更多功能

4.2 Executor框架

// 創建線程池
ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任務
executor.submit(() -> {
    System.out.println("Task running");
});

// 關閉線程池
executor.shutdown();

4.3 ThreadPoolExecutor參數

new ThreadPoolExecutor(
    corePoolSize,    // 核心線程數
    maximumPoolSize, // 最大線程數
    keepAliveTime,   // 空閑線程存活時間
    unit,            // 時間單位
    workQueue,       // 工作隊列
    threadFactory,   // 線程工廠
    handler          // 拒絕策略
);

五、原子操作類

5.1 AtomicInteger

AtomicInteger counter = new AtomicInteger(0);

// 原子遞增
counter.incrementAndGet();

// CAS操作
boolean success = counter.compareAndSet(expect, update);

5.2 LongAdder

高并發場景下性能優于AtomicLong：

LongAdder adder = new LongAdder();
adder.increment();
long sum = adder.sum();

六、并發集合

6.1 ConcurrentHashMap

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
map.computeIfAbsent("key", k -> 2);

6.2 CopyOnWriteArrayList

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("item");
list.get(0); // 讀取不需要同步

七、Future與CompletableFuture

7.1 Future基本使用

Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "Result";
});

String result = future.get(); // 阻塞獲取結果

7.2 CompletableFuture

CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(s -> s + " World")
    .thenAccept(System.out::println);

八、最佳實踐

1. 盡量使用高層并發工具
2. 優先選擇不可變對象
3. 縮小同步范圍
4. 避免死鎖（按固定順序獲取鎖）
5. 考慮使用線程局部變量（ThreadLocal）
6. 合理設置線程池參數

結語

Java并發編程是一個龐大而復雜的主題，本文僅介紹了基礎概念和常用工具。要真正掌握并發編程，需要深入理解Java內存模型（JMM），并在實際項目中不斷實踐和優化。隨著Java版本的更新，并發API也在不斷演進（如虛擬線程等），開發者需要持續學習新的技術和最佳實踐。

注意：本文示例代碼僅用于演示概念，實際使用時需要考慮異常處理、資源釋放等細節。 “`

這篇文章大約2200字，涵蓋了Java并發編程的主要基礎知識點，采用Markdown格式編寫，包含代碼示例和表格對比，結構清晰。如需進一步擴展某個主題或添加更多實踐案例，可以繼續補充相關內容。