JUC ---- 新建线程的三种方式

新建线程一般有三种方式:

一种是继承Thread（但是由于Java是单继承机制，继承该类之后，将无法继承其他类，所以推出了Runnable接口的方式）
一种是实现Runnable接口 (没有返回值，不可抛出异常)
一种是实现Callable接口 (有返回值，可以抛出异常)

1. 继承了类Thread

[1] 继承Thread类，重写run方法
[2] new出该类并执行start方法

public class newThread {

    /*继承了Thread接口的*/
    private static class useThread extends  Thread{
        @Override
        public void run() {
            System.out.println("I am extends Thread");
        }
    }
	
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.继承了Thread类
        new useThread().start();
    }     
 }   

2. 实现Runnable接口

[1] 实现Runnable接口，重写run方法
[2] new 出该类后，必须借助Thread类的包装后，才能调用start方法

public class newThread {

   /*实现Runnable接口*/
    private static class UseRun implements  Runnable{

        @Override
        public void run() {
            System.out.println("I am implements  Runnable");
        }
    }
	
	public static void main(String[] args) throws ExecutionException, InterruptedException {
         //2. 实现了Runnable接口
        UseRun useRun = new UseRun();
        new Thread(useRun).start();
    }     
 }   

3. 实现了Callable接口

[1] 实现Callable接口，重写call方法，这个方法可以抛出异常，可以携带返回值
[2] 实现了Callable的类，不能直接转换为Thread类，它必须通过FutureTask转换为Runnable类后，才能进一步转换。
[3] 通过Thread类包装后调用start方法。

public class newThread {

   /*实现Callable接口,允许有返回值*/
    private static class UseCall implements Callable<String>{

        @Override
        public String call() throws Exception {
            System.out.println("I am implements Callable");
            return "callResult";
        }
    }
	
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3. 实现了Callable接口
        UseCall useCall = new UseCall();
        FutureTask<String> futureTask = new FutureTask<>(useCall);
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }     
 }