并行编程在Java中如何实现

在Java中，有多种方法可以实现并行编程

1. 使用Thread类：

class MyThread extends Thread {
    public void run() {
        // 在这里编写你的代码
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

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

2. 使用Runnable接口：

class MyRunnable implements Runnable {
    public void run() {
        // 在这里编写你的代码
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);

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

3. 使用ExecutorService和Callable接口：

import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        // 在这里编写你的代码并返回结果
        return 0;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        Future<Integer> future1 = executorService.submit(new MyCallable());
        Future<Integer> future2 = executorService.submit(new MyCallable());

        System.out.println("Result 1: " + future1.get());
        System.out.println("Result 2: " + future2.get());

        executorService.shutdown();
    }
}

4. 使用ForkJoinPool和RecursiveAction接口：

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class Main {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();

        forkJoinPool.invoke(new MyRecursiveAction());
    }
}

class MyRecursiveAction extends RecursiveAction {
    @Override
    protected void compute() {
        // 在这里编写你的代码
    }
}

这些示例展示了如何在Java中实现并行编程。你可以根据自己的需求选择合适的方法。