Java 实现并发的几种方式小结

在 Java 中，实现并发有多种方式，本文将对其中的几种方式进行介绍及总结。

使用 Thread 类实现并发

Thread 类是 Java 中用于实现多线程的基类。使用 Thread 类实现并发的方式是创建一个继承 Thread 类的子类，子类中重写 run() 方法，run() 方法中定义需要执行的代码。

示例代码：

public class MyThread extends Thread {
    public void run() {
        // 需要执行的代码
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        // 开启线程
        thread1.start();
        thread2.start();
    }
}

使用 Thread 类实现并发的优缺点：

优点：
- 实现简单，代码易读。
- 能够直接使用 Thread 类提供的方法进行线程处理。

缺点：
- 每个线程拥有自己的对象和变量，占用较多内存。
- 同时使用多个线程时，线程之间的数据不能共享。

使用 Runnable 接口实现并发

Runnable 接口比 Thread 类更加灵活，使用 Runnable 接口实现并发的方式是创建一个实现 Runnable 接口的类，实现类中重写 run() 方法。

示例代码：

public class MyRunnable implements Runnable {
    public void run() {
        // 需要执行的代码
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        // 开启线程
        thread1.start();
        thread2.start();
    }
}

使用 Runnable 接口实现并发的优缺点：

优点：
- 更加灵活，能够实现多个接口，方便扩展。
- 在资源共享方面更强，多个线程可以共享同一个资源。

缺点：
- 不能直接使用 Thread 类提供的方法进行线程处理，需要使用 Thread 对象。

使用 Callable 和 Future 接口实现并发

Callable 和 Future 接口提供了一种更加高级的并发实现方式。Callable 接口可以返回对象，并支持多线程并发访问，Future 接口则可以获取 Callable 接口返回的对象。

示例代码：

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        // 需要执行的代码
        return 10;
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            // 获取返回值
            Integer result = futureTask.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用 Callable 和 Future 接口实现并发的优缺点：

优点：
- 更加高级，支持返回值和异常处理。
- 能够通过 Future 接口获得返回结果。

缺点：
- 实现方式较为复杂，需要使用 FutureTask 对象来获取结果。

使用 Executor 框架实现并发

Executor 框架是 Java 提供的一个用于管理、控制和执行线程的框架。该框架包括了 Executor、ExecutorService 和 ThreadPoolExecutor 三个主要接口，能够方便地实现并发。

示例代码：

public class MyRunnable implements Runnable {
    public void run() {
        // 需要执行的代码
    }

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executor.submit(new MyRunnable());
        }
        executor.shutdown();
    }
}

使用 Executor 框架实现并发的优缺点：

优点：
- 可以控制线程的数量，降低线程争用所带来的风险。
- 能够自动管理线程的生命周期。

缺点：
- 可能存在线程饥饿问题，某些线程可能因为一些原因无法获得执行的机会。

总结

Java 实现并发的几种方式各有优缺点，选择合适的方式需要根据具体的场景综合考虑。在实现时应根据实际情况选择最适合的方式，以达到满足需求的目的。