殷龙飞的博客

Java技术专家面试专题系列（二）：Java并发编程

 面试/技术专家  1977  4 分钟

并发编程是Java技术专家必须精通的领域，它直接关系到系统性能和稳定性。本篇将从线程基础、同步机制、线程池、JUC工具包到CAS与原子类，系统讲解Java并发编程的核心知识，旨在为你提供扎实的理论基础和实战能力，应对高级面试挑战。

1. 线程基础

线程是Java并发的基础，理解其创建和生命周期至关重要。

  • 创建方式

    • 继承Thread类。
    • 实现Runnable接口。
    • 使用Callable和Future（带返回值）。
    • Lambda表达式（推荐）。

  • 线程状态

    • 新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、等待（Waiting）、超时等待（Timed Waiting）、终止（Terminated）。

示例: 使用Callable获取线程结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import java.util.concurrent.*;

public class ThreadCreationDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Callable<String> task = () -> "Task completed after 1 second!";
        Future<String> future = executor.submit(task);
        Thread.sleep(1000); // 模拟延迟
        System.out.println(future.get()); // 输出: Task completed after 1 second!
        executor.shutdown();
    }
}

面试问题:

  • 问题: Runnable和Callable的区别是什么？
  • 答案: Runnable无返回值，run()方法不抛异常；Callable有返回值，通过Future获取结果，call()方法可抛异常。

2. 同步机制

多线程访问共享资源时，同步机制确保数据一致性。

  • synchronized关键字

    • 作用于方法或代码块，保证同一时刻只有一个线程访问。
    • 底层通过Monitor实现。

  • Lock接口（ReentrantLock）

    • 提供更灵活的控制，如公平锁、条件变量。

  • volatile关键字

    • 确保变量可见性，禁止指令重排序，但不保证原子性。

示例: ReentrantLock同步计数器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.concurrent.locks.ReentrantLock;

public class LockDemo {
    private static int count = 0;
    private static final ReentrantLock lock = new ReentrantLock();

    public static void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 确保释放锁
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> { for (int i = 0; i < 1000; i++) increment(); };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start(); t2.start();
        t1.join(); t2.join();
        System.out.println("Final count: " + count); // 输出: 2000
    }
}

面试问题:

  • 问题: synchronized和ReentrantLock的区别？
  • 答案: synchronized是关键字，自动释放锁；ReentrantLock是类，手动释放，支持公平锁和条件等待，适用于复杂场景。

3. 线程池

线程池通过复用线程提高效率，ThreadPoolExecutor是核心实现。

  • 核心参数

    • corePoolSize: 核心线程数。
    • maximumPoolSize: 最大线程数。
    • keepAliveTime: 空闲线程存活时间。
    • workQueue: 任务队列。

  • 拒绝策略

    • AbortPolicy（抛异常）、CallerRunsPolicy（调用者执行）等。

示例: 自定义线程池

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2, 4, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(10),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy()
        );

        for (int i = 0; i < 15; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " executing task " + taskId);
                try { Thread.sleep(500); } catch (Exception e) {}
            });
        }
        executor.shutdown();
    }
}

面试问题:

  • 问题: 线程池的任务执行顺序是什么？
  • 答案: 先填满核心线程，超出的任务进队列，队列满后创建额外线程，直到maximumPoolSize，再触发拒绝策略。

4. JUC并发工具

java.util.concurrent（JUC）包提供了高级并发工具。

  • CountDownLatch

    • 等待多个线程完成。

  • Semaphore

    • 控制并发访问量。

  • CompletableFuture

    • 异步编程，支持链式调用。

示例: CountDownLatch同步任务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " finished");
            latch.countDown();
        };

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

        latch.await(); // 主线程等待
        System.out.println("All tasks completed!");
    }
}

面试问题:

  • 问题: CountDownLatch和Semaphore的区别？
  • 答案: CountDownLatch用于等待一组线程完成，计数减到0触发；Semaphore控制并发访问资源，计数表示许可数。

5. CAS与原子类

CAS（Compare-And-Swap）是无锁编程的核心，原子类封装了CAS操作。

  • CAS原理

    • 比较当前值与预期值，相等则更新，否则重试。

  • 原子类

    • AtomicInteger、AtomicReference等。

  • ABA问题

    • 值从A变为B再变回A，CAS误判。

示例: AtomicInteger与ABA修复

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import java.util.concurrent.atomic.AtomicStampedReference;

public class CASDemo {
    private static AtomicStampedReference<Integer> value = new AtomicStampedReference<>(1, 0);

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int[] stampHolder = new int[1];
            int oldValue = value.get(stampHolder);
            int oldStamp = stampHolder[0];
            try { Thread.sleep(100); } catch (Exception e) {}
            boolean success = value.compareAndSet(oldValue, 3, oldStamp, oldStamp + 1);
            System.out.println("T1 update: " + success + ", value: " + value.getReference());
        });

        Thread t2 = new Thread(() -> {
            int[] stampHolder = new int[1];
            int v = value.get(stampHolder);
            value.compareAndSet(v, 2, stampHolder[0], stampHolder[0] + 1); // A -> B
            value.compareAndSet(2, 1, stampHolder[0] + 1, stampHolder[0] + 2); // B -> A
        });

        t1.start();
        t2.start();
    }
}

面试问题:

  • 问题: 如何解决ABA问题？
  • 答案: 使用AtomicStampedReference引入版本号，CAS检查值和版本一致性。

6. 学习与面试建议

  • 实践: 编写多线程代码，模拟竞争和同步场景。
  • 深入: 阅读JUC源码，如ReentrantLock和ConcurrentHashMap。
  • 表达: 用原理和示例清晰回答问题，如CAS的工作流程。

结语

Java并发编程是技术专家的核心竞争力，掌握线程管理、同步机制和无锁编程，能让你在面试和实战中游刃有余。下一专题将深入探讨JVM深入剖析，敬请期待！

updatedupdated2025-04-172025-04-17

相关文章：