创建线程的四种方式（Thread、Runnable、线程池、Callable）

目录

一、直接继承Thread类，然后重写run方法

二、实现Runnable接口

三、线程池创建

四、实现Callable接口

---

        创建线程有四种方式：1、继承Thread类   2、实现Runnable接口  3、通过线程池创建  4、实现Callable接口，下面是具体介绍

一、直接继承Thread类，然后重写run方法

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

---

二、实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

简化版（匿名内部类）

public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
            }
        });
        thread.start();
    }

  套娃再简化

public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
            }
        }).start();
    }

        上述两种方法的比较：首先运行的时候代码不一样，方法一直接用实例对象调用start即可，方法二需要先实例化为Thread对象，再调用start。其次的话就是要考虑继承与实现的不同，单继承多实现。

        run与start的不同：run是单纯的调用你重写的方法体内容，而start才是真正的开启线程。run是同步，start是异步。

---

三、线程池创建

        线程池其实容纳多个线程的容器，可以不用重复创建线程，减少资源的浪费。介绍一下Executors 提供四种线程池：

1）newCachedThreadPool  ：线程池根据需求创建线程,可扩容,创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程.

    特点：

1.     线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）
2.     线程池中的线程可进行缓存重复利用和回收（回收默认时间为 1 分钟）
3.     当线程池中，没有可用线程，会重新创建一个线程

    场景: 适用于创建一个可无限扩大的线程池，服务器负载压力较轻，执行时间较短，任务多的场景

2）newSingleThreadExecutor ：一个任务一个任务执行，一池一线程（例如窗口只能服务一个人，后面来的只能等待）。创建是一个单线程池，也就是该线程池只有一个线程在工作，所有的任务是串行执行的，如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它，此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

    特点： 线程池中最多执行 1 个线程，之后提交的线程活动将会排在队列中以此执行

    场景: 适用于需要保证顺序执行各个任务，并且在任意时间点，不会同时有多个线程的场景

3）newFixedThreadPool (int) ：一池N线程，创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小，线程池的大小一旦达到最大值就会保持不变。

    特征：

1.     线程池中的线程处于一定的量，可以很好的控制线程的并发量
2.     线程可以重复被使用，在显示关闭之前，都将一直存在
3.     超出一定量的线程被提交时候需在队列中等待

    场景: 适用于可以预测线程数量的业务中，或者服务器负载较重，对线程数有严格限制的场景

 4）newScheduledThreadPool （了解）：创建一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求。

    场景: 适用于需要多个后台线程执行周期任务的场景

 // 一池5线程
        // ExecutorService threadPool = Executors.newFixedThreadPool(5);
        // 一池一线程
        // ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 一池可扩容线程
        // ExecutorService threadPool = Executors.newCachedThreadPool();

---

也可以自己用new ThreadPoolExecutor创建线程池，里面有几个参数值得注意：

1）corePoolSize：3     线程池的核心线程数（常驻线程数）

线程池的核心线程数（常驻线程数），一般情况下不管有没有任务都会一直在线程池中一直存活

2）maximumPoolSize：  7   线程池所能容纳的最大线程数

线程池所能容纳的最大线程数，当活动的线程数达到这个值后，后续的新任务将会被阻塞。

3）keepAliveTime：4      线程闲置时的超时时长

控制线程闲置时的超时时长，超过则终止该线程。一般情况下用于非核心线程

4）unit： 时间单位

用于指定 keepAliveTime 参数的时间单位，TimeUnit 是个 enum 枚举类型，常用的有：TimeUnit.HOURS(小时)、TimeUnit.MINUTES(分钟)、TimeUnit.SECONDS(秒) 和 TimeUnit.MILLISECONDS(毫秒)等。

5）workQueue：任务队列（阻塞队列）

当核心线程数达到最大时，新任务会放在任务队列中排队等待执行。

6）threadFactory：线程工厂

线程工厂，它是一个接口，用来为线程池创建新线程的。

7）RejectedExecutionHandler handler: 拒绝策略

 最后用线程池调用execute方法创建线程：

for (int i = 1; i <=10; i++) {
            final int index = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "为第"+index+"个任务服务");
                }
            });
        }

这里用final是因为匿名内部类要使用常量，否则会报错

---

四、实现Callable接口

 Callable与Runable类似，它是JDK1.5之后才出现的。

与Thread区别：相比于callable来说,thread没有返回值,且效率没有callable高

与Runnable区别： 

1. 可以有返回值
2. 可以抛出异常
3. 方法不同，分别是call()和run()

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        //需要适配类和Thread建立关联
        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask, "CallableDemo");
        thread.start();
        String str = futureTask.get();
        System.out.println(str);
    }
}

class MyCallable implements Callable{

    @Override
    public String call() throws Exception {
        System.out.println("MyCallable.call");
        return "abc";
    }
}