线程创建方式（Thead，Runnable，Callable）

一 ：继承Thread 类

public class ThreadDemo {


// 1. 继承Thread 类实现run方法
    class MyThread extends Thread{
        @Override
        public void run() {
            super.run();

            System.out.println("开启线程");
        }
    }

    public static void main(String[] args) {

        // 2 实例化 MyThread 对象
        ThreadDemo.MyThread myThread=new ThreadDemo().new MyThread();

        //3. 启动线程
        myThread.start();


    }
}

二：实现Runnable 接口

public class ThreadDemoRunable {
    // 1.实现Runnable接口
    class  MyRunable implements Runnable{

        @Override
        public void run() {

            System.out.println( Thread.currentThread().getName()+"开启线程");
        }
    }
    public static void main(String[] args) {

        //2.实例化Runnable 接口
        ThreadDemoRunable.MyRunable myRunable=new ThreadDemoRunable().new MyRunable();
        //3.实例化 Thread 对象
        Thread thread=new Thread(myRunable);
        thread.setName("runnable ");
        //4. 启动线程
        thread.start();
    }
}

三：实现 Callable 接口

public class ThreadDemoCalladle {


    //1 实现Callable 接口
    class  myCallable  implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            return 100;
        }
    }


    public  void startThreadByCallable(){
        //2.创建 FutureTask 包装对象
        FutureTask futureTask=new FutureTask(new myCallable());
        //3. 创建对象 并启动线程
        new Thread(futureTask).start();

        try {
            //4. 获取 线程方法返回值
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {

        // 5. 调用线程
        new ThreadDemoCalladle().startThreadByCallable();
    }
}

方法	差异
继承 Thead	实现简单，但是不能实现多继承
实现 Runnable	实现也不算复杂，避免单一继承的缺点，数据共享
实现 Callable	实现也稍稍复杂，避免单一继承的缺点，数据共享，相比Runnable 可以有返回值