浅析java的Runnable,Callable和Thread三种创建线程的方式

java线程的创建方式有三种，但形式和效果各不相同，具体的差异如下

实现的理解    Runnable    Callable    Thread
实现方式    需要继承Runnable    需要实现Callable    继承Thread
是否支持线程池    支持，实现Runnable的类可以由Future类，交由 ExecutorService的execute方法执行    支持，实现Callable的类可以由Future类，交由 ExecutorService的execute方法执行    否
是否支持异步回调    否    支持，可自定义回调的数据类型    否
思想    组合和拓展思想    组合和拓展思想    
单继承

Runnable和Thread的区别
由于java支持单继承，继承Thread是只能继承Thread，但实现Runnable接口，还可以继承其他类，影  响 只是覆盖了基本的run方法
继承Thread类无法实现重用，实现Runnable可以运行可以多种方式运行，如还支持Executor方式
Thread是继承，Runnable是组合和拓展的思想。
Callable和Runnable的区别
callable可以抛异常，但Runnable不支持

callable可以获取回调值，Runnable不支持

二者的异步线程池的任务提交方式不同，参上

package com.example.day01;
 
import java.util.concurrent.*;
 
/**
 * Thread createMethod
 *    1. 继承Thread
 *    2. 实现Runnable
 *    3. 实现Callable
 *
 * Thread 和Runnable的区别：
 *    由于java支持单继承，继承Thread是只能继承Thread，但实现Runnable接口，还可以继承其他类，影响只是覆盖了基本的run方法
 *    继承Thread类无法实现重用，实现Runnable可以运行可以多种方式运行，如还支持Executor方式
 *    Thread是继承，Runnable是组合和拓展的思想。
 *Callable
 *
 */
 
public class ThreadCreateMethod {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //继承Thread方式
        ExtendThread extendThread =new ExtendThread();
        new Thread(extendThread).start();
        new Thread(extendThread).start();
        new Thread(extendThread).start();
        //实现Runnable接口方式
        ImplRunnable implRunnable=new ImplRunnable();
        new Thread(implRunnable).start();
        new Thread(implRunnable).start();
        new Thread(implRunnable).start();
        //实现callable
        ImplCallable implCallable =new ImplCallable();
        FutureTask future=new FutureTask(implCallable);
        new Thread(future,"t1").start();
        new Thread(future,"t2").start();
        //支持回调
        System.out.println(future.get());
        //线程池的方式
        ExecutorService executorService=Executors.newScheduledThreadPool(8);
        executorService.submit(future);
        executorService.shutdown();
 
 
 
 
 
 
 
    }
 
}
class ExtendThread extends Thread{
    private int num=100;
    @Override
    public void run() {
        /***
         * 存在超卖问题
         * */
        System.out.println("继承Thread类方法");
        while(num>0){
            if(num>0){
                num--;
                System.out.println(num);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else{
                break;
            }
        }
    }
}
class ImplRunnable implements Runnable{
    private int num=100;
    private int num1=0;
    @Override
    public void run() {
        /***
         * 存在超卖问题
         * */
        System.out.println("实现Runnable");
        while(true){
           if(num>0){
               num--;
               num1++;
               System.out.println(Thread.currentThread().getName()+num+" "+num1);
 
           } else{
               break;
           }
 
        }
    }
 
 
}
class ImplCallable implements Callable<String>{
    private int num=100;
    private int num1=0;
    @Override
    public String call() throws Exception {
        /***
         * 不存在超卖问题
         * */
        System.out.println("实现callable");
        while(true){
            if(num>0){
                num--;
                num1++;
                System.out.println(num+","+num1);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else{
                break;
            }
 
        }
        return "执行完毕";
    }
}

————————————————
版权声明：本文为CSDN博主「bug制造生产者」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_73368873/article/details/126911880