创建线程的四种方法。既继承Thread类，又实现实现Runnable接口时，会执行谁的run()方法？

创建线程的方法：

1. 继承Thread类重写run()方法。
2. 实现Runnable接口，重写run()方法。
3. 实现Callable接口，重写call()方法，通过FutureTask包装器来创建线程。
4. 使用线程池创建线程。

其实方法1和方法2经常使用，方法3、4倒是我不怎么用。今天就研究一下方法3、4创建线程的方式。

实现Callable接口创建线程

public class CallableDemo implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        Thread.sleep(5000);
        return 0;
    }

    public static void main(String[] args) {
        FutureTask<Integer> result=new FutureTask<>(new CallableDemo());
        Thread thread=new Thread(result);
        thread.start();
        System.out.println("start");
        try {
            System.out.println("result:"+result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

这种方式需要借助FutureTask类来支持。优于方法1、2的一点是可以添加返回值，并且可以抛出异常。

但是需要注意的一点是，如果需要获取返回值result.get()这个方法是阻塞的。所以你在创建线程和调用result.get()方法之间没有耗时操作 或者 没有其他线程 效果和顺序执行没有区别，还不如不创建线程。

使用线程池创建线程

public class RunnableDemo implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

    public static void main(String[] args) {
        // 创建一个固定大小的线程池:
        ExecutorService es = Executors.newFixedThreadPool(4);
        for (int i = 0; i < 6; i++) {
            es.submit(new RunnableDemo());
        }
        // 关闭线程池:
        es.shutdown();
    }
}

1. newFixedThreadPool 创建固定大小数量线程池，数量通过传入的参数决定。
2. newSingleThreadExecutor 创建一个线程容量的线程池，所有的线程依次执行，相当于创建固定数量为1的线程池。
3. newCachedThreadPool 创建可缓存的线程池，没有最大线程限制（实际上是Integer.MAX_VALUE）。如果用空闲线程等待时间超过一分钟，就关闭该线程。
4. newScheduledThreadPool 创建计划(延迟)任务线程池,线程池中的线程可以让其在特定的延迟时间之后执行，也可以以固定的时间重复执行（周期性执行）。相当于以前的Timer类的使用。
5. newSingleThreadScheduledExecutor 创建单线程池延迟任务，创建一个线程容量的计划任务。

实现Runnable接口创建线程

最常用的还是实现Runnable接口的方式创建线程。

• 由于Java是单继承，如果继承了Thread类就不能继承其他类了。

• 如果线程只是用一次的话也不需要专门写一个类，直接使用匿名内部类的方式。还可以结合jdk8的lambda表达式。

public class RunnableDemo{

    public static void main(String[] args) {
        new Thread(()->{
            for (int i = 0; i < 100; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Runnable:"+i);
            }
        }).start();
    }
}

一个经典的线程面试题

如何一个类既继承了Thread类，又实现了Runnable接口。运行start方法的时候是执行重写Thread类里面的run()方法还是执行重写Runnable接口里面的run()方法？如下程序输出什么？

    public static void main(String[] args) {
        new Thread(()-> System.out.println("Runnable")){
            @Override
            public void run() {
                System.out.println("Thread");
            }
        }.start();
    }

结果输出的是“Thread”。

我们来看一下Thread类的源码。

public class Thread implements Runnable {    
    private Runnable target;
    
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
	@Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
}

我只放了部分方法，init()方法也不放了，内容就是把传过来的target赋值个this.target。Thread类的run()方法里面的逻辑就是target!=null调用target.run()。

我们继承了Thread类，重写了run()方法，当调用start()方法后，JVM帮我们调用的是重写后的run()方法，也就执行不到target的run()方法了。因此输出结果为”Thread“