java并发编程的基础

发布时间：2021-08-25 18:37:02 作者：chen
来源：亿速云阅读：109

# 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 线程生命周期

NEW：新建状态
RUNNABLE：可运行状态
BLOCKED：阻塞状态
WTING：等待状态
TIMED_WTING：定时等待状态
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 锁机制比较

特性	synchronized	ReentrantLock
实现方式	JVM内置	JDK实现
可中断	不支持	支持
公平锁	非公平	可配置
条件变量	有限支持	支持
性能	优化后较好	较高

三、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 线程池优势

降低资源消耗
提高响应速度
提高线程可管理性
提供更多功能

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);

八、最佳实践

尽量使用高层并发工具
优先选择不可变对象
缩小同步范围
避免死锁（按固定顺序获取锁）
考虑使用线程局部变量（ThreadLocal）
合理设置线程池参数

结语

Java并发编程是一个庞大而复杂的主题，本文仅介绍了基础概念和常用工具。要真正掌握并发编程，需要深入理解Java内存模型（JMM），并在实际项目中不断实践和优化。随着Java版本的更新，并发API也在不断演进（如虚拟线程等），开发者需要持续学习新的技术和最佳实践。

注意：本文示例代码仅用于演示概念，实际使用时需要考虑异常处理、资源释放等细节。 “`

这篇文章大约2200字，涵盖了Java并发编程的主要基础知识点，采用Markdown格式编写，包含代码示例和表格对比，结构清晰。如需进一步扩展某个主题或添加更多实践案例，可以继续补充相关内容。