Java程序在Ubuntu上如何实现并发

在Ubuntu上使用Java实现并发，可以通过多种方式来完成。以下是一些常见的方法：

1. 多线程（Multithreading）: Java提供了内置的多线程支持，可以通过继承Thread类或实现Runnable接口来创建线程。

   class MyThread extends Thread {
       public void run() {
           // 线程执行的代码
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           MyThread t1 = new MyThread();
           MyThread t2 = new MyThread();
           t1.start(); // 启动线程
           t2.start();
       }
   }
   

   或者使用Runnable接口：

   class MyRunnable implements Runnable {
       public void run() {
           // 线程执行的代码
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           Thread t1 = new Thread(new MyRunnable());
           Thread t2 = new Thread(new MyRunnable());
           t1.start();
           t2.start();
       }
   }
   

2. 并发API（java.util.concurrent）: Java 5引入了java.util.concurrent包，它提供了更高级的并发工具，如线程池、同步器、并发集合等。

   • 线程池 (Executors):

     import java.util.concurrent.ExecutorService;
     import java.util.concurrent.Executors;
     
     public class Main {
         public static void main(String[] args) {
             ExecutorService executor = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池
             executor.submit(new MyRunnable());
             executor.submit(new MyRunnable());
             executor.shutdown(); // 关闭线程池
         }
     }
     

   • 同步器 (CountDownLatch, CyclicBarrier, Semaphore等):

     import java.util.concurrent.CountDownLatch;
     
     public class Main {
         public static void main(String[] args) throws InterruptedException {
             CountDownLatch latch = new CountDownLatch(2);
             Thread t1 = new Thread(new MyRunnable(latch));
             Thread t2 = new Thread(new MyRunnable(latch));
             t1.start();
             t2.start();
             latch.await(); // 等待两个线程完成
         }
     }
     
     class MyRunnable implements Runnable {
         private CountDownLatch latch;
     
         public MyRunnable(CountDownLatch latch) {
             this.latch = latch;
         }
     
         public void run() {
             // 线程执行的代码
             latch.countDown(); // 减少计数器
         }
     }
     

3. Fork/Join框架: 对于可以分解成更小任务的计算密集型任务，可以使用Fork/Join框架来实现任务的并行处理。

   import java.util.concurrent.RecursiveTask;
   import java.util.concurrent.ForkJoinPool;
   
   public class Main {
       public static void main(String[] args) {
           ForkJoinPool pool = new ForkJoinPool();
           int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
           int sum = pool.invoke(new SumTask(array, 0, array.length));
           System.out.println("Sum: " + sum);
       }
   }
   
   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;
           }
       }
   }
   

4. 并行流（Parallel Streams）: Java 8引入了流（Streams）API，可以很容易地将集合转换为并行流，从而实现并发处理。

   import java.util.Arrays;
   import java.util.List;
   
   public class Main {
       public static void main(String[] args) {
           List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
           int sum = numbers.parallelStream().reduce(0, Integer::sum);
           System.out.println("Sum: " + sum);
       }
   }
   

以上就是在Ubuntu上使用Java实现并发的一些常见方法。选择哪种方法取决于具体的应用场景和需求。