Java 并发与并行的区别?

在现代软件开发中，理解并发与并行的区别是至关重要的。这不仅有助于编写高效的代码，还能帮助我们更好地设计系统架构。本文将详细探讨并发与并行的概念，并结合Java源码进行剖析。

并发和并行的定义

并发 (Concurrency)：指在同一时间段内，系统可以处理多个任务。这些任务可能交替执行，但在任何给定的时刻，只有一个任务在执行。并发系统依赖于任务切换和调度来实现多任务处理。

并行 (Parallelism)：指在同一时刻，系统同时执行多个任务。这通常需要多核处理器，每个任务在不同的核心上运行。

核心区别

• 并发：任务在同一时间段内执行，但不一定同时进行。
• 并行：任务在同一时刻同时进行。

并发与并行的实际案例

在Java中，我们可以使用线程来实现并发和并行。下面通过代码示例来说明这两者的区别。

并发示例

以下示例展示了如何使用Java线程实现并发。这里的任务是让两个线程交替打印数字。

java

public class ConcurrencyExample {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Task(), "Thread 1");
        Thread thread2 = new Thread(new Task(), "Thread 2");

        thread1.start();
        thread2.start();
    }
}

class Task implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(100); // 模拟任务执行时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在上述代码中，两个线程 thread1 和 thread2 在同一时间段内交替执行各自的任务。这是典型的并发执行。

并行示例

接下来，我们使用Java的并行流（Parallel Streams）来实现并行处理。并行流利用多个线程同时处理任务。

java

import java.util.Arrays;
import java.util.List;

public class ParallelExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        numbers.parallelStream().forEach(number -> {
            System.out.println(Thread.currentThread().getName() + " - " + number);
        });
    }
}

在上述代码中，parallelStream() 方法会将列表中的任务分配给不同的线程，从而实现真正的并行处理。

深入剖析Java并发包

Java提供了一系列强大的并发工具类，这些类位于 java.util.concurrent 包中。接下来，我们将探讨其中几个关键类及其源码实现。

线程池 (Thread Pool)

线程池是管理线程的核心工具，可以重用现有线程，避免频繁创建和销毁线程带来的开销。下面是一个使用 Executors 创建线程池的示例：

java

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        for (int i = 1; i <= 5; i++) {
            executor.execute(new Task());
        }
        executor.shutdown();
    }
}

源码解读：

Executors.newFixedThreadPool(2) 的实现实际上是调用了 ThreadPoolExecutor 的构造方法：

java

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

ThreadPoolExecutor 是线程池的核心实现类，其构造方法参数如下：

• corePoolSize：核心线程数。
• maximumPoolSize：最大线程数。
• keepAliveTime：非核心线程的最大空闲时间。
• unit：空闲时间的单位。
• workQueue：任务队列。

通过这些参数，线程池可以灵活配置以应对不同的并发需求。

并发集合 (Concurrent Collections)

Java还提供了一系列并发集合类，如 ConcurrentHashMap、CopyOnWriteArrayList 等。这些集合类在多线程环境下提供了更高效和安全的操作。

示例：

java

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(Thread.currentThread().getName() + " - " + key + ": " + value);
        });
    }
}

源码解读：

ConcurrentHashMap 通过分段锁机制来提高并发性能。以下是其 put 方法的简化版实现：

java

public V put(K key, V value) {
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key, value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        // omitted for brevity
                    }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}