目录

1. Java线程模型

示例代码：创建线程的两种方式

2. 同步机制与锁

示例代码：synchronized的使用

显式锁（ReentrantLock）

3. Java并发工具包（java.util.concurrent）

线程池（Executor Framework）

线程安全集合

4. Fork/Join框架

示例代码：Fork/Join框架

总结

---

并发编程的深入探索（3/5）

在现代计算机硬件中，多核处理器的普及让并发编程变得越来越重要。Java作为一种成熟的编程语言，提供了多种工具和API来帮助开发者编写高效的并发代码。这篇文章将深入探讨Java线程模型、同步机制、并发工具包（java.util.concurrent）以及Fork/Join框架，帮助你全面掌握Java的并发编程。

1. Java线程模型

Java线程模型是理解并发编程的核心。Java中的线程可以通过继承Thread类或实现Runnable接口来创建。

示例代码：创建线程的两种方式

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

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

public class ThreadCreationExample {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.start();

        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
    }
}

在上述代码中，MyThread通过继承Thread类实现，而MyRunnable通过实现Runnable接口实现。这两种方式都是创建线程的基本方法。

创建线程方式	特性
继承Thread类	直接创建线程，简单但不支持多继承
实现Runnable接口	支持实现多个接口，推荐使用

2. 同步机制与锁

在多线程环境中，多个线程可能会竞争共享资源，导致竞态条件（Race Condition）。为了解决这个问题，我们可以使用同步机制来确保线程安全。

Java提供了多种同步机制来解决共享资源的问题，包括synchronized关键字和显式锁（如ReentrantLock）。

示例代码：synchronized的使用

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

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

        System.out.println("Final count: " + counter.getCount());
    }
}

在这个例子中，increment()方法使用了synchronized关键字，确保在多线程环境中只有一个线程能够同时执行该方法，从而保证了数据的安全性。

显式锁（ReentrantLock）

除了synchronized关键字，Java还提供了ReentrantLock类来实现显式锁定。

import java.util.concurrent.locks.ReentrantLock;

class LockCounter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

ReentrantLock提供了更灵活的锁机制，比如支持中断和非阻塞地尝试获取锁。

3. Java并发工具包（java.util.concurrent）

Java 5引入了java.util.concurrent并发工具包，极大地简化了并发编程的难度。这些工具包包括线程池、同步工具类、并发集合等。

线程池（Executor Framework）

线程池是一种管理线程的机制，可以有效地提高性能并减少资源消耗。

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

public class ExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            executor.execute(() -> {
                System.out.println("Thread: " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

在这个例子中，我们创建了一个固定大小为3的线程池，通过execute()方法执行任务。线程池可以重用线程，从而减少线程创建和销毁的开销。

并发工具类	用途
ExecutorService	管理线程池，执行并发任务
CountDownLatch	控制一个或多个线程等待多个操作完成
Semaphore	控制对资源的并发访问

线程安全集合

java.util.concurrent包中提供了一些线程安全的集合，如ConcurrentHashMap、CopyOnWriteArrayList，可以安全地在多线程环境中使用。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("A", 1);
        map.put("B", 2);

        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}

在多线程环境中，ConcurrentHashMap可以提供更高的并发性和更好的性能，而不需要显式同步。

4. Fork/Join框架

Fork/Join框架是Java 7中引入的一个并行计算框架，用于将大任务拆分成多个小任务，并行执行以提高效率。ForkJoinPool是Fork/Join框架的核心类。

示例代码：Fork/Join框架

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

class SumTask extends RecursiveTask<Integer> {
    private final int[] arr;
    private final int start, end;
    private static final int THRESHOLD = 10;

    public SumTask(int[] arr, int start, int end) {
        this.arr = arr;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= THRESHOLD) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += arr[i];
            }
            return sum;
        } else {
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(arr, start, mid);
            SumTask rightTask = new SumTask(arr, mid, end);
            leftTask.fork();
            int rightResult = rightTask.compute();
            int leftResult = leftTask.join();
            return leftResult + rightResult;
        }
    }
}

public class ForkJoinExample {
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }

        ForkJoinPool pool = new ForkJoinPool();
        SumTask task = new SumTask(arr, 0, arr.length);
        int result = pool.invoke(task);
        System.out.println("Sum: " + result);
    }
}

在这个例子中，我们使用RecursiveTask实现了一个任务，将数组分成小块并行求和。Fork/Join框架非常适合需要将大任务拆分为小任务的场景。

总结

在本篇文章中，我们深入探讨了Java中的并发编程，包含线程的创建、同步机制、并发工具包及Fork/Join框架。并发编程是一个复杂但非常重要的主题，尤其在当前的多核处理器环境下，掌握Java的并发编程工具可以大大提升代码的执行效率和响应能力。

在接下来的文章中，我们将讨论Java性能调优与垃圾回收机制，帮助你理解如何进一步提升Java应用的性能。希望通过这篇文章的学习，你对Java的并发编程有了更深入的理解，并能够在项目中灵活运用这些知识。