Java - 多线程 Thread、Runnable、Callable的区别

在Java中，Thread、Runnable和Callable是用于实现多线程的三种主要方式，它们在用法和功能上有一些区别。

1. Thread：Thread是Java的一个内置类，用于表示一个线程。当我们直接继承Thread类并覆盖其run()方法时，就可以创建一个新的线程。

创建线程方法：

例如：

class MyThread extends Thread {
	@Override
    public void run() {
        // 线程执行的代码
    }
}

 // 线程对象调用start()方法
  MyThread myThread = new MyThread();
  myThread.start();

然而，继承Thread类只能用于实现简单的线程，对于需要共享资源和复杂线程协作的场景，则不太适用。

2. Runnable：Runnable是一个接口，它定义了一个run()方法，当线程开始执行时，run()方法将被调用。与Thread类不同，Runnable不继承Thread类，而是将Runnable接口传递给Thread构造函数。

创建线程方法：

例如：

class MyRunnable implements Runnable {
	@Override
    public void run() {
        // 线程执行的代码
    }
}

// 线程对象调用start()方法
Thread thread = new Thread(new MyRunnable());
thread.start();

Runnable的优点是可以避免Java的单继承限制，并且可以更方便地实现共享资源的访问控制。

3. Callable：Callable也是一个接口，与Runnable类似，它定义了一个call()方法，当线程开始执行时，call()方法将被调用。与Runnable不同的是，Callable可以返回结果，并且可以抛出异常。为了获取Callable任务的结果，我们需要使用FutureTask类或者Future和ExecutorService接口。

创建线程方法：
方式一：FutureTask类

注意：上方不是重写run()方法，是重写call()方法，并需要抛出异常
方式二：

注意：上方不是重写run()方法，是重写call()方法，并需要抛出异常

例如：

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
            System.out.println(Thread.currentThread() + "正在计算：" + i);
        }
        return sum;
    }
}

//  方式一： 
// 准备线程1
MyCallable myCallable1 = new MyCallable();
FutureTask<Integer>  futureTask1 = new FutureTask<>(myCallable1);
// 准备线程2
MyCallable myCallable2 = new MyCallable();
FutureTask<Integer>  futureTask2 = new FutureTask<>(myCallable2);
// 开启线程1
new Thread(futureTask1).start();
// 开启线程2
new Thread(futureTask2).start();
// 获取返回值
Integer result1 = futureTask1.get();
System.out.println("任务1：" + result1 );
Integer result2 = futureTask2.get();
System.out.println("任务2：" + result2 );

// 方式二：
class MyCallable implements Callable<Integer> {  
    public Integer call() throws Exception {  
        // 线程执行的代码  
        return result;  
    }  
}  
ExecutorService executor = Executors.newFixedThreadPool(1);  
Future<Integer> future = executor.submit(new MyCallable());  
Integer result = future.get(); // 获取任务结果  
executor.shutdown();

Callable主要用于需要返回结果的任务，而Runnable是不支持返回结果的。

4. 还有一种方式，匿名内部类：

public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("匿名内部类：" + i);
                }
            }
        }).start();

        for (int i = 0; i < 100;i++) {
            System.out.println("main：" + i);
        }
    }

总结一下：

• 如果要实现一个简单的线程，并且不需要返回结果或共享资源，那么可以直接使用Thread类。
• 如果需要实现一个可以返回结果的线程，或者需要共享资源并控制访问，那么应该使用Runnable接口配合Future和ExecutorService接口。
• 如果需要实现一个需要返回结果并且可以抛出异常的线程，那么应该使用Callable接口配合Future和ExecutorService接口。