【JAVA】Java高级：多线程与并发编程——Java并发包（java.util.concurrent）

在高性能、响应迅速的应用程序中，并发编程是一个至关重要的主题。Java语言通过其并发包（java.util.concurrent）为开发者提供了一套强大的工具，以便于在多线程环境中安全、有效地处理并发任务。

比如，一个在线购物网站，在促销期间，成千上万的用户同时访问并下订单。如果系统无法有效地处理这些并发请求，可能会导致崩溃、数据不一致或响应缓慢，从而影响用户体验和业务收入。因此，合理使用并发技术可以提高系统的吞吐量和响应能力。

一、Java并发包概述

Java的并发包主要提供了以下几个重要的组件：

1. 线程池：管理和复用线程，避免频繁创建和销毁线程。

2. 同步工具：如锁、信号量等，用于控制线程之间的访问。

3. 并发集合：如ConcurrentHashMap，提供线程安全的数据结构。

4. 原子变量：提供无锁的线程安全操作。

5. 并发框架：如Fork/Join框架，适合处理大规模并行任务。

二、线程池（Executor框架）

线程池是并发编程中最常用的工具之一。通过线程池，系统可以复用线程，减少线程创建和销毁的开销。

1. 创建线程池

Java提供了Executors类来创建不同类型的线程池。

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交多个任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 正在执行 by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}

代码解析

• Executors.newFixedThreadPool(3)：创建一个固定大小的线程池，最多同时执行3个线程。

• executor.submit(...)：提交任务到线程池，线程池会从池中获取空闲线程来执行任务。

• executor.shutdown()：关闭线程池，等待所有任务完成后关闭。

三、同步工具

在多线程环境中，确保共享资源的安全访问是至关重要的。Java并发包提供了多种同步工具。

1. ReentrantLock

ReentrantLock是一个可重入的互斥锁，它提供了比synchronized更灵活的锁机制。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                lock.lock(); // 获取锁
                try {
                    count++; // 访问共享资源
                } finally {
                    lock.unlock(); // 确保释放锁
                }
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("最终计数: " + count);
    }
}

代码解析

• lock.lock()：尝试获取锁，如果锁被其他线程持有，当前线程会阻塞。

• try-finally结构：确保即使在任务执行过程中发生异常，也能释放锁。

• lock.unlock()：释放锁，允许其他线程获取锁。

四、并发集合

并发集合提供了线程安全的数据结构，避免了手动同步的复杂性。

1. ConcurrentHashMap

ConcurrentHashMap是一个线程安全的哈希表，允许多个线程并发访问。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                map.put(Thread.currentThread().getName() + "-" + i, i);
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("并发哈希表大小: " + map.size());
    }
}

代码解析

• ConcurrentHashMap：允许多个线程同时读写而不需要额外的同步。

• map.put(...)：多个线程可以同时执行put操作，而不会引发数据不一致的问题。

五、原子变量

Java并发包提供了原子变量类，例如AtomicInteger，用于无锁的线程安全操作。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    private static final AtomicInteger atomicCount = new AtomicInteger(0);

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                atomicCount.incrementAndGet(); // 原子性增加
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("最终计数: " + atomicCount.get());
    }
}

代码解析

• AtomicInteger：提供了一种无锁的方式来更新整数值。

• incrementAndGet()：原子性地将值加1并返回更新后的值，确保在多线程环境中安全。

六、Fork/Join框架

Fork/Join框架用于处理大规模并行任务，特别适合递归任务。

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

public class ForkJoinExample extends RecursiveTask<Long> {
    private final long start;
    private final long end;

    public ForkJoinExample(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if (end - start <= 10) { // 基线条件
            long sum = 0;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            long middle = (start + end) / 2;
            ForkJoinExample leftTask = new ForkJoinExample(start, middle);
            ForkJoinExample rightTask = new ForkJoinExample(middle + 1, end);
            leftTask.fork(); // 异步执行左边的任务
            long rightResult = rightTask.compute(); // 同步执行右边的任务
            long leftResult = leftTask.join(); // 等待左边任务完成
            return leftResult + rightResult;
        }
    }

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinExample task = new ForkJoinExample(1, 100);
        long result = pool.invoke(task);
        System.out.println("1到100的和: " + result);
    }
}

代码解析

• RecursiveTask<Long>：用于定义可以返回结果的任务。

• compute()：实现具体的任务逻辑，分割任务并合并结果。

• fork()和join()：用于异步执行和等待结果。

七、总结

Java的并发包为开发者提供了强大的工具和类库，使得多线程编程变得更加简单和安全。通过合理使用线程池、同步工具、并发集合和原子变量，可以有效地提高应用程序的性能和响应能力。

在实际开发中，选择合适的并发工具和模式非常重要，需要根据具体的应用场景和需求来决定。