Java并行和并发有什么区别？

Java并行和并发有什么区别？

并行和并发是两个在多线程编程中经常使用的概念，它们描述了不同的多任务处理方式。

1. 并发（Concurrency）：

   • 定义：并发是指多个任务共享资源，但是并不一定同时执行。它强调的是多个任务之间有交替的执行，通过任务切换来实现。
   • 目的：提高系统的效率，充分利用 CPU 时间片，使得多个任务看起来是同时在执行。

   下面是一个简单的并发示例，使用 Java 的 Thread 类：

   public class ConcurrencyExample {
       public static void main(String[] args) {
           Runnable task = () -> {
               for (int i = 0; i < 5; i++) {
                   System.out.println(Thread.currentThread().getName() + ": " + i);
               }
           };
   
           Thread thread1 = new Thread(task);
           Thread thread2 = new Thread(task);
   
           thread1.start();
           thread2.start();
       }
   }
   

   在这个例子中，两个线程共享同一个任务，并发地执行。输出结果可能是交替的，因为两个线程在运行时会交替执行。

2. 并行（Parallelism）：

   • 定义：并行是指多个任务同时执行，每个任务独占一个 CPU 核心。它强调的是多个任务在同一时刻同时执行，实现真正的并行计算。
   • 目的：提高系统的处理能力，通过同时处理多个任务来加速整体计算。

   下面是一个简单的并行示例，使用 Java 的 ForkJoinPool：

   import java.util.concurrent.ForkJoinPool;
   import java.util.concurrent.RecursiveTask;
   
   public class ParallelismExample {
       static class SumTask extends RecursiveTask<Integer> {
           private static final int THRESHOLD = 2;
           private int[] array;
           private int start;
           private int end;
   
           public SumTask(int[] array, int start, int end) {
               this.array = array;
               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 += array[i];
                   }
                   return sum;
               } else {
                   int middle = (start + end) / 2;
                   SumTask leftTask = new SumTask(array, start, middle);
                   SumTask rightTask = new SumTask(array, middle, end);
   
                   leftTask.fork();
                   int rightResult = rightTask.compute();
                   int leftResult = leftTask.join();
   
                   return leftResult + rightResult;
               }
           }
       }
   
       public static void main(String[] args) {
           ForkJoinPool forkJoinPool = new ForkJoinPool();
           int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
   
           int sum = forkJoinPool.invoke(new SumTask(array, 0, array.length));
           System.out.println("Sum: " + sum);
       }
   }
   

   在这个例子中，ForkJoinPool 实现了并行计算，通过拆分任务进行递归处理。这种方式可以利用多个 CPU 核心同时进行计算，实现并行性。

总的来说，并发强调任务之间的交替执行，而并行强调任务的同时执行。在实际的应用中，这两者可以结合使用，根据任务的性质和系统的硬件情况选择合适的策略。