[Java知识库]Java多线程的三种实现方式（继承Thread ，实现Runnable接口，实现Callable接口）

1、继承Thread 实现run方法

public class ThreadDemo1 {
    public static void main(String[] args) {
        // 线程执行 调用 start方法
        MyThread m = new MyThread();
        m.start();
        for (int i = 0; i < 10; i++) {
            System.out.println("main执行" + i);
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("m在执行"+ i);
        }
    }
}

结果1：

main执行0
main执行1
main执行2
main执行3
main执行4
main执行5
main执行6
main执行7
main执行8
main执行9
m在执行0
m在执行1
m在执行2
m在执行3
m在执行4
m在执行5
m在执行6
m在执行7
m在执行8
m在执行9

结果2：

main执行0
main执行1
m在执行0
main执行2
m在执行1
main执行3
m在执行2
main执行4
m在执行3
main执行5
main执行6
main执行7
main执行8
main执行9
m在执行4
m在执行5
m在执行6
m在执行7
m在执行8
m在执行9

2、 实现Runnable接口

步骤：
1. 创建任务对象， 任务对象实现Runnable接口
2. 创建线程，在其构造方法中传入任务对象
3. 调用 线程的start方法 使用线程。

public class ThreadDemo1 {
    public static void main(String[] args) {
        // 实现Runnable
        // 1. 创建任务对象
        MyRunnable m = new MyRunnable();
        // 2. 创建一个线程，并为其分配一个任务
        Thread t = new Thread(m);
        // 执行线程t
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行" + i);
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("m任务执行" + i);
        }
    }
}

结果：

主线程执行0
m任务执行0
m任务执行1
主线程执行1
主线程执行2
主线程执行3
主线程执行4
主线程执行5
主线程执行6
m任务执行2
m任务执行3
m任务执行4
m任务执行5
m任务执行6
m任务执行7
m任务执行8
m任务执行9
主线程执行7
主线程执行8
主线程执行9

实现Runnable 与 继承Thread相比的优势：

1. 通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同的任务的情况。
2. 可以避免单继承所带来的局限性
3. 任务与线程本身是分离的，提高了程序的健壮性
4. 使用线程池技术，接收Runnable类型的任务，不接收Thread类型的线程

3、 Callable接口

使用步骤：

1. 编写类实现Callable接口 , 实现call方法

   class XXX implements Callable<T> {
       @Override public <T> call() throws Exception { 
           return T; 
       } 
   }
   

2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象

   FutureTask<Integer> future = new FutureTask<>(callable);
   

3. 通过Thread,启动线程

   new Thread(future).start();
   

不调用get：

public class CallableDemo {
    public static void main(String[] args) throws InterruptedException {
        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(callable);
        new Thread(task).start();
        // 不调用 get 方法
        for (int i = 0; i < 5; i++) {
            Thread.sleep(10);
            System.out.println("main线程" + i);
        }
    }
}
class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 5; i++) {
            Thread.sleep(10);
            System.out.println(Thread.currentThread().getName() + i);
        }
        return 3000;
    }
}

结果：

main线程0
Thread-00
main线程1
Thread-01
Thread-02
main线程2
Thread-03
main线程3
Thread-04
main线程4

调用get 就会等结果返回之后，主线程才开始执行

public class CallableDemo {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Integer> callable = new MyCallable();
        FutureTask<Integer> task = new FutureTask<>(callable);
        new Thread(task).start();
        // 调用 get 方法
        Integer res = task.get();
        System.out.println("返回的结果：" + res);
        for (int i = 0; i < 5; i++) {
            Thread.sleep(10);
            System.out.println("main线程" + i);
        }
    }
}
class MyCallable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 5; i++) {
            Thread.sleep(10);
            System.out.println(Thread.currentThread().getName() + i);
        }
        return 3000;
    }
}

结果：

Thread-00
Thread-01
Thread-02
Thread-03
Thread-04
返回的结果：3000
main线程0
main线程1
main线程2
main线程3
main线程4

FutureTask类的其他方法：

Runnable与 Callable的相同点

• 都是接口

• 都可以编写多线程程序

• 都采用Thread.start()启动线程

Runnable 与 Callable的不同点

• Runnable没有返回值；Callable可以返回执行结果

• Callable接口的call()允许抛出异常；Runnable的run()不能抛出