详解三种java实现多线程的方式

详解三种java实现多线程的方式

在Java中，实现多线程有3种方式：继承Thread类、实现Runnable接口以及使用Callable和Future接口。每种方式都有自己的优缺点，具体实现方式如下：

继承Thread类

Java的每个线程都是通过Thread类的实例来实现的，因此第一种实现多线程的方式是创建继承自Thread类的子类，重写run()方法。例如：

class MyThread extends Thread {
    public void run() {
        // 实现多线程逻辑
    }
}

此时创建MyThread对象时，可以直接调用对象的start()方法启动线程，例如：

MyThread thread = new MyThread();
thread.start();

这种方式简单易懂，但也有其缺点。由于Java只允许单继承，因此如果需要继承其他类，就无法使用该方式。

实现Runnable接口

Java允许实现接口来实现多线程，因此第二种实现多线程的方式是创建实现Runnable接口的类，并实现run()方法。例如：

class MyRunnable implements Runnable {
    public void run() {
        // 实现多线程逻辑
    }
}

此时可以通过创建Thread对象，并将MyRunnable的实例传入Thread对象的构造函数来启动线程，例如：

MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

该方式相较于继承Thread类的方式，优点在于可以避免单继承导致的问题，同时还能更好地分离线程执行代码和线程构造代码。

使用Callable和Future接口

第三种实现多线程的方式是使用Callable和Future接口。Callable接口类似于Runnable接口，只不过call()方法可以返回线程执行结果，而Runnable接口的run()方法没有返回值。Future接口则表示一个异步计算的结果。例如：

class MyCallable implements Callable<String> {
    public String call() throws Exception {
        return "Hello";
    }
}

此时可以通过创建ExecutorService对象来启动线程，例如：

MyCallable myCallable = new MyCallable();
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(myCallable);
String result = future.get();

以上代码创建了一个ExecutorService对象，并通过submit()方法提交了MyCallable实例。该方法返回一个Future对象，通过调用get()方法可以获得线程执行结果。

示例1：使用Runnable接口实现斐波那契数列生成器

下面给出一个使用Runnable接口实现的斐波那契数列生成器示例，其代码如下：

public class FibonacciRunnable implements Runnable {
    private final int n;

    public FibonacciRunnable(int n) {
        this.n = n;
    }

    public void run() {
        int a = 1, b = 1;
        for (int i = 0; i < n; i++) {
            System.out.print(a + " ");
            int temp = a + b;
            a = b;
            b = temp;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        FibonacciRunnable fibonacciRunnable = new FibonacciRunnable(10);
        Thread thread = new Thread(fibonacciRunnable);
        thread.start();
    }
}

该实现中重写了Runnable接口的srun()方法，并在该方法中实现了斐波那契数列的生成逻辑。在main()方法中创建了一个Thread对象，并将FibonacciRunnable实例传入该对象的构造函数中，然后调用start()方法启动线程。

示例2：使用Callable和Future接口计算斐波那契数列

下面给出一个使用Callable和Future接口实现的斐波那契数列生成器示例，其代码如下：

public class FibonacciCallable implements Callable<Integer> {
    private final int n;

    public FibonacciCallable(int n) {
        this.n = n;
    }

    public Integer call() throws Exception {
        int a = 1, b = 1;
        for (int i = 0; i < n - 2; i++) {
            int temp = a + b;
            a = b;
            b = temp;
        }
        return b;
    }

    public static void main(String[] args) throws Exception {
        FibonacciCallable fibonacciCallable = new FibonacciCallable(10);
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Integer> future = executorService.submit(fibonacciCallable);
        int result = future.get();
        System.out.println(result);
    }
}

在该示例中，创建了一个FibonacciCallable类，实现了Callable接口的call()方法。在该方法中实现了斐波那契数列的生成逻辑，并返回了生成结果。在main()方法中，通过创建ExecutorService对象并调用submit()方法来提交该生成器，得到一个Future对象，通过调用get()方法来获取线程计算的结果。最终结果输出在控制台上。