使用Runnable、Thread、Callable三种方法实现多线程

一、Runnable
1.创建一个 MyRunnable 测试类实现 Runnable 接口；
2.重写 Runnable 接口中的 run() 方法；
3.使用参数为 Runnable 对象的构造方法创建 Thread 实例；
4.调用 start() 方法启动线程；

public class Test_Runnable {
    public static void main(String[] args) {
        // 创建 MyRunnable 测试类
        MyRunnable myRunnable = new MyRunnable();
        // 使用参数为Runnable对象的构造方法创建Thread实例,并调用 start() 方法启动线程
        new Thread(myRunnable).start();
    }

    static class MyRunnable implements Runnable{  // 继承 Runnable 接口

        // 重写 run() 方法
        @Override
        public void run() {
                // 获取当前线程名称
            System.out.println("当前线程名称：");
            System.out.println(Thread.currentThread().getName()+": "+"Hello World");
        }
    }
}

运行结果：

当前线程名称：
Thread-0: Hello World

二、Thread
1.创建 MyThread 测试类继承 Thread 类；
2.MyThread类 覆盖 Thread 类中的 run() 方法；
3.创建 Thread 实例，并调用 start() 方法启动线程；

public class Test_Thread {
    public static void main(String[] args) {
        // 创建 MyThread 测试类对象
        MyThread myThread = new MyThread();
        // 调用 start() 方法启动线程
        myThread.start();
    }

    static class MyThread extends Thread{ // 继承 Thread 类
        // 子类覆盖 Thread 类中的 run() 方法
        @Override
        public void run() {
            System.out.println("线程已启动！！！");
        }
    }
}

运行结果：

线程已启动！！！

注意：创建一个 Thread实例后，需覆盖 run() 方法，run() 方法中是此线程需要执行的任务，然后调用 start() 方法启动该线程。
三、Callable
Callable是一个功能接口，Callable接口类似于Runnable接口，但是Callable创建线程时可以返回一个结果。，而Runnable接口创建的线程不能返回结果。实现Callable接口时需通过泛型指定返回的类型。
1.创建 MyCallable 测试类实现 Callable接口，并指定返回类型；
2.重写 call() 方法；
3.使用FutureTask来获取 call() 的返回值；
4.使用get() 方法来获取执行结果时，该方法会产生阻塞，会一直等到任务执行完毕获取执行结果。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Test_Callable {
    public static void main(String[] args) {
        // 创建 Callable 实例
        Callable<String> callable = new MyCallable();
        // 通过FutureTask来获取 call() 返回的结果
        FutureTask<String> futureTask = new FutureTask<>(callable);
        new Thread(futureTask).start();
        try {
            // 阻塞
            String temp = futureTask.get();
            System.out.println("返回值为："+ temp);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    static class MyCallable implements Callable<String>{
        // 重写 call() 方法
        @Override
        public String call() throws Exception {
            // 休眠 3 秒
            Thread.sleep(3000);
            return "Hello World";
        }
    }
}

运行结果：

返回值为：Hello World

注意: Callable接口的 call() 方法可以返回一个结果并且可以抛出异常，而Runnable和Thread的 run() 方法无法返回结果和抛出异常。