Java并发编程实战指南：从基础到应用-CSDN博客

本文链接：https://blog.csdn.net/hellojava6666/article/details/147628241

引言

在当今多核处理器普及的时代，有效利用并发编程技术可以显著提升程序性能。本文将通过理论讲解与代码实践，带你掌握Java并发编程的核心技术。

一、什么是并发编程？

并发编程是指通过创建多个独立执行的线程，让程序同时处理多个任务的编程范式。不同于串行执行，并发程序可以：

提高CPU利用率
增强系统吞吐量
改善用户体验（如响应式界面）

但同时也带来线程安全、死锁等挑战。

二、Java并发编程基础实现

1. 线程创建方式

方式一：继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程执行: " + Thread.currentThread().getName());
    }
}

// 启动线程
new MyThread().start();

方式二：实现Runnable接口（推荐）

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable线程: " + Thread.currentThread().getName());
    }
}

// 使用线程池执行
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(new MyRunnable());

2. 线程同步机制

synchronized关键字

class Counter {
    private int count = 0;
    
    // 同步方法
    public synchronized void increment() {
        count++;
    }
    
    // 同步代码块
    public void add(int value) {
        synchronized(this) {
            count += value;
        }
    }
}

ReentrantLock显式锁

class SafeList {
    private final Lock lock = new ReentrantLock();
    private List<String> list = new ArrayList<>();

    public void addItem(String item) {
        lock.lock();
        try {
            list.add(item);
        } finally {
            lock.unlock();
        }
    }
}

3. 原子操作类

AtomicInteger atomicInt = new AtomicInteger(0);

// 多线程安全自增
IntStream.range(0, 100)
         .parallel()
         .forEach(i -> atomicInt.incrementAndGet());
System.out.println("最终值: " + atomicInt.get()); // 保证输出100

4. 线程间协作

CountDownLatch示例

CountDownLatch latch = new CountDownLatch(3);

Runnable task = () -> {
    System.out.println("任务执行完成");
    latch.countDown();
};

new Thread(task).start();
new Thread(task).start();
new Thread(task).start();

latch.await(); // 等待所有任务完成
System.out.println("所有任务已完成");

三、并发编程最佳实践

优先使用线程池（避免直接创建线程）

ExecutorService executor = Executors.newCachedThreadPool();
Future<Integer> future = executor.submit(() -> {
    TimeUnit.SECONDS.sleep(1);
    return 42;
});
System.out.println("异步结果: " + future.get());

2. 使用并发集合类

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

避免死锁（按固定顺序获取锁）

四、常见问题解决方案

问题类型	解决方案
竞态条件	使用synchronized/Lock同步
内存可见性	使用volatile关键字
线程阻塞	使用非阻塞算法/并发队列
资源死锁	定时锁尝试（tryLock）