【Java多线程】三种创建线程的方式及Runnable与Callable的比较-优快云博客

本文链接：https://blog.youkuaiyun.com/Johnny_sc/article/details/110443618

本文详细介绍了Java中创建线程的三种方法：继承Thread类、实现Runnable接口以及使用Callable接口。通过对比分析，得出通过实现Runnable或Callable接口更为灵活，尤其在多线程共享资源时。一般推荐使用实现接口的方式实现多线程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

创建线程的三种方法

1. 继承Thread类

步骤：

(1)定义一个类继承Thread类，并重写Thread类的run()方法，run()方法的方法体就是线程要完成的任务，因此把run()称为线程的执行体；

(2)创建该类的实例对象，即创建了线程对象；

(3)调用线程对象的start()方法来启动线程；

public class ThreadDemo {
    public static void main(String[] args){
        Thread t = new myThread();
        t.start();
    }
}
class myThread extends Thread{
    @Override
    public void run(){
        System.out.println("thread working...");
    }
}

2. 实现Runnable接口

步骤：

(1)定义一个类实现Runnable接口；

(2)创建该类的实例对象obj；

(3)将obj作为构造器参数传入Thread类实例对象，这个对象才是真正的线程对象；

(4)调用线程对象的start()方法启动该线程；

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}

代码相关注释：

1、Runnable实现类的对象是Thread的target（参数形式），Runnable实现类里包含的run()方法仅仅作为线程执行体，而实际的线程对象依然是Thread实例，Thread实例负责执行其target的run()方法；

2、通过实现Runnable接口来实现多线程时，要获取当前线程对象只能通过Thread.currentThread()方法，而不能通过this关键字获取；

3、从JAVA8开始，Runnable接口使用了@FunctionalInterface修饰，也就是说Runnable接口是函数式接口，可使用lambda表达式创建对象，使用lambda表达式就可以不像上述代码一样还要创建一个实现Runnable接口的类，然后再创建类的实例。代码如下：

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("start new thread!");
        });
        t.start(); // 启动新线程
    }
}

3. 通过callable接口的实现类FutureTask

Callable接口是Runnable接口的增强版，Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大，体现在：

1、call()方法可以有返回值；

2、call()方法可以声明抛出异常；

问题在于，Callable接口不是Runnable的子接口，不能像Runnable实现类那样作为Thread的target，并且call()方法有返回值，所以不能被直接调用，需要作为线程执行体被执行，那么怎么实现线程调用呢？

回答：通过Future接口的实现类——FutureTask来实现，FutureTask实现了Future和Runnable两个接口，所以可以作为Thread的target

通过Callable接口实现多线程的步骤

1、创建Callable接口实现类，并实现call()方法，该方法将作为线程执行体，且该方法有返回值，再创建Callable实现类的实例；

2、使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；

3、使用FutureTask对象作为Thread对象的target创建并启动新线程；

4、调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

public class main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask(new MyCallable());
        Thread thread = new Thread(futureTask);

        thread.start();
        System.out.println(futureTask.get());
    }
}

class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("entering run method...");
        return 3000;
    }
}

使用Lambda表达式

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //这里call()方法的重写是采用lambda表达式，没有新建一个Callable接口的实现类
        FutureTask<Integer> task =  new FutureTask<Integer>((Callable<Integer>)()->{
            int i = 0;
            for(;i < 50;i++) {
                System.out.println(Thread.currentThread().getName() +
                        "  的线程执行体内的循环变量i的值为：" + i);
            }
            //call()方法的返回值
            return i;
        });

        for(int j = 0;j < 50;j++) {
            System.out.println(Thread.currentThread().getName() +
                    " 大循环的循环变量j的值为：" + j);
            if(j == 20) {
                new Thread(task,"myThread666").start();
            }
        }
        try {

            System.out.println("子线程的返回值：" + task.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}