Java并发编程教学：从基础到实践

引言

在当今多核处理器普及的时代，并发编程已成为Java开发者必须掌握的核心技能之一。合理利用并发可以显著提高程序性能，但同时也带来了复杂性。本文将带你系统学习Java并发编程的基础知识、核心概念和实用技巧。

一、并发编程基础

1. 线程与进程的区别

• 进程：操作系统资源分配的基本单位，拥有独立的内存空间

• 线程：CPU调度的基本单位，共享进程的内存空间

// 创建线程的两种基本方式
// 方式1：继承Thread类
class MyThread extends Thread {
    public void run() {
        System.out.println("线程运行中...");
    }
}

// 方式2：实现Runnable接口
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable线程运行中...");
    }
}

public class Main {
    public static void main(String[] args) {
        new MyThread().start();
        new Thread(new MyRunnable()).start();
    }
}

2. 线程生命周期

• NEW（新建）

• RUNNABLE（可运行）

• BLOCKED（阻塞）

• WAITING（等待）

• TIMED_WAITING（计时等待）

• TERMINATED（终止）

二、Java并发核心机制

1. synchronized关键字

synchronized是Java中最基本的同步机制，可用于方法或代码块。

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

2. volatile关键字

volatile确保变量的可见性，但不保证原子性。

class SharedObject {
    private volatile boolean flag = false;
    
    public void setFlag() {
        flag = true;
    }
    
    public boolean getFlag() {
        return flag;
    }
}

三、Java并发工具类

1. ReentrantLock

比synchronized更灵活的锁机制。

import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

2. CountDownLatch

允许一个或多个线程等待其他线程完成操作。

import java.util.concurrent.CountDownLatch;

public class Worker implements Runnable {
    private final CountDownLatch startSignal;
    private final CountDownLatch doneSignal;
    
    Worker(CountDownLatch start, CountDownLatch done) {
        this.startSignal = start;
        this.doneSignal = done;
    }
    
    public void run() {
        try {
            startSignal.await(); // 等待主线程信号
            doWork();
            doneSignal.countDown(); // 完成工作后计数减一
        } catch (InterruptedException ex) {
            // 处理中断
        }
    }
    
    void doWork() { /* ... */ }
}

3. Concurrent集合

Java提供了一系列线程安全的集合类：

import java.util.concurrent.*;

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
BlockingQueue<String> queue = new LinkedBlockingQueue<>();

四、线程池管理

1. Executor框架

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        
        System.out.println("所有线程执行完毕");
    }
}

2. 自定义线程池

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // 核心线程数
    10, // 最大线程数
    120, // 空闲线程存活时间
    TimeUnit.SECONDS, // 时间单位
    new ArrayBlockingQueue<>(100) // 工作队列
);

五、常见并发问题与解决方案

1. 死锁及预防

// 死锁示例
public class DeadlockDemo {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized(lock1) {
            synchronized(lock2) {
                // ...
            }
        }
    }
    
    public void method2() {
        synchronized(lock2) {
            synchronized(lock1) {
                // ...
            }
        }
    }
}

预防策略：

• 按固定顺序获取锁

• 使用tryLock()设置超时

• 避免嵌套锁

2. 线程安全设计原则

1. 优先使用不可变对象

2. 封装共享数据

3. 使用线程安全类

4. 减小同步范围

5. 避免过度同步

六、Java内存模型(JMM)

理解Java内存模型对编写正确的并发程序至关重要：

• 原子性

• 可见性

• 有序性

// 正确使用volatile的例子
class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

七、Java 8+并发新特性

1. CompletableFuture

CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "结果";
}).thenApply(result -> {
    // 处理结果
    return result + "处理";
}).thenAccept(finalResult -> {
    // 消费最终结果
    System.out.println(finalResult);
});

2. 并行流

List<String> list = Arrays.asList("a", "b", "c");
list.parallelStream().forEach(System.out::println);

结语

Java并发编程是一个庞大而复杂的主题，需要不断学习和实践。建议从简单的例子开始，逐步深入理解各种并发概念和工具。记住，并发编程的首要目标是正确性，其次才是性能优化。

进一步学习资源：

• 《Java并发编程实战》

• 《Java并发编程的艺术》

• Oracle官方Java并发教程

希望这篇博客能为你开启Java并发编程的学习之旅提供帮助！