一文看懂Java中创建线程的所有方式（继承Thread,实现Runnable，实现Callable,线程池）

╰+攻爆jí腚メ 2023-07-21 06:14 9阅读 0赞

# 一文看懂Java中创建线程的所有方式 #

> 好像有点标题党的感觉，但是干货绝对多，绝对有收获
> 
> 本文部分参考周阳老师大厂面试题第二讲
> 
> 觉得有用，点个赞吧

**目录**

1、继承Thread类

2、实现Runnable接口

3、 实现callable接口

4、使用线程池

线程池的几个重要参数介绍

线程池的底层工作原理

生产上如何合理设置线程池参数

自定义线程池

线程池的拒绝策略

面试题:合理配置线程池你是如何考虑的？

--------------------

## 1、继承Thread类 ##

这是最基本的方式，继承Thread类并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。

**代码示例如下：**

//继承Thread类 Thread本质上也是实现了Runnable 接口的一个实例，它代表一个线程的实例，
    class MyThread extends Thread {
        public void run() {
            //继承Thread创建线程 具体实现
        }
    }
    
    //启动线程
    new MyThread().start();

## 2、实现Runnable接口 ##

定义Runnable接口的实现类，一样要重写run()方法，这个run()方法和Thread中的run()方法一样是线程的执行体

创建Runnable实现类的实例，并用这个实例作为Thread的target来创建Thread对象，这个Thread对象才是真正的线程对象

//Runable方式实现
    class MyThread2 implements Runnable {
    
        @Override
        public void run() {
            //Runable方式创建线程 具体实现
        }
    }
    
    //启动线程
      new Thread(new MyThread2()).start();

** 补充：**我们看一下Thread类的源码

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

当我们采用实现Runnable接口的方式来实现线程的情况下，在调用new Thread(Runnable target)构造器时，将实现了Runnable接口的类的实例设置成了线程要执行的主体所属的目标对象target，当线程启动时，这个实例的 run()方法就被执行了。

当我们采用继承Thread的方式实现线程时，线程的这个run()方法被重写了，所以当线程启动时，执行的是这个对象自身的 run()方法。

总结起来：**如果我们采用的是继承Thread类的方式，那么这个target就是线程对象自身，如果我们采用的是实现Runnable接口的方式，那么这个target就是实现了Runnable接口的类的实例。**

## 3、 实现callable接口 ##

> 通过实现callable接口的方式，可以创建一个线程，需要重写其中的call方法。
> 
> 步骤：新建一个Callable的实例，再用FutureTask实例包装它，最终，再包装成Thread实例。
> 
> 调用start方法启动，并且，可以通过FutureTask的get方法来获取返回值。在形式上，相比于Runnable接口，call方法多了一个**泛型的返回值和抛出了一个异常。**可以通过futureTask.get()方法获取返回值，但需要值得注意的时，执行get()方法的时候，会强制执行完这个线程得到返回值，所以一般可以放在后面

public class CallableDemo {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
    
            FutureTask<Integer> futureTask = new FutureTask<>(new MyThread2());
            //System.out.println(futureTask.get());如果在调用start()方法前，调用get()会导致阻塞
            new Thread(futureTask, "线程A").start();//
            System.out.println(futureTask.get());
    
        }
    }
    
    
    //Callable方式实现
    class MyThread3 implements Callable<Integer> {
    
        @Override
        public Integer call() throws Exception {
            System.out.println("**** come in ****");
            return 1024;
        }
    }

**输出：**

> \*\*\*\* come in \*\*\*\*  
> 1024

**补充：**如果我们在两个线程中传进同一个futureTask，只会执行一次

**输出：**

> \*\*\*\* come in \*\*\*\*  
> 1024  
> 1024

要想执行两次，我们需要两个不同的futureTask。

public class CallableDemo {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
    
            FutureTask<Integer> futureTask = new FutureTask<>(new MyThread2());
            FutureTask<Integer> futureTask2 = new FutureTask<>(new MyThread2());
            new Thread(futureTask, "线程A").start();
            new Thread(futureTask2, "线程B").start();
            System.out.println(futureTask.get());
            System.out.println(futureTask2.get());
    
        }
    }

**输出：**

**** come in ****
    **** come in ****
    1024
    1024

**补充：**实现Callable接口和实现Runnable接口的区别

区别1: 两者最大的区别，实现Callable接口的任务线程能返回执行结果，而实现Runnable接口的任务线程不能返回执行结果

注意点：Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞线程直到获取“将来”的结果，当不调用此方法时，主线程不会阻塞

区别2:Callable接口实现类中run()方法允许将异常向上抛出，也可以直接在内部处理(try...catch); 而Runnable接口实现类中run()方法的异常必须在内部处理掉，不能向上抛出

Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。

**主要方法：**

boolean cancel(boolean mayInterruptIfRunning)：试图取消该Future里面关联的Callable任务

V get()：返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值

V get(long timeout,TimeUnit unit)：返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException

boolean isDone()：若Callable任务完成，返回True

boolean isCancelled()：如果在Callable任务正常完成前被取消，返回True

## 4、使用线程池 ##

> Java中的线程池是通过Executor框架实现的，该框架中用到了Executor,Executors,ExecutorService,ThreadPoolExecutor
> 
> 实现有五种，Executors.newScheduledThreadPool()是带时间调度的，
> 
> java8新推出Executors.newWorkStealingPool(int),使用目前机器上可用的处理器作为他的并行级别

**这里介绍Java中常用的三种线程池：**

**1、Executors.newCachedThreadPool();**

**执行很多短期异步的小程序或负载较轻的服务器**

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX\_VALUE,使用的SynchronousQueue,也就是说来了任务就创建线程运行，当县城空闲超过60s，就销毁线程

public class ThreadPoolDemo {
        public static void main(String[] args) {
            ExecutorService threadPool = Executors.newCachedThreadPool();
    
            try {
                for (int i = 0; i < 10; i++) {
                    threadPool.execute(() -> {
                        System.out.println(Thread.currentThread().getName() + "办理业务");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                threadPool.shutdown();
            }
        }
    }

输出：

> pool-1-thread-1办理业务  
> pool-1-thread-5办理业务  
> pool-1-thread-4办理业务  
> pool-1-thread-3办理业务  
> pool-1-thread-2办理业务  
> pool-1-thread-8办理业务  
> pool-1-thread-7办理业务  
> pool-1-thread-9办理业务  
> pool-1-thread-6办理业务  
> pool-1-thread-10办理业务

**2、Executors.newSingleThreadExecutor()**

**创建一个单线程话的线程池，他只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行**

newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，使用LinkedBlockingQueue

public class ThreadPoolDemo {
        public static void main(String[] args) {
            ExecutorService threadPool = Executors.newSingleThreadExecutor();
    
            try {
                for (int i = 0; i < 10; i++) {
                    threadPool.execute(() -> {
                        System.out.println(Thread.currentThread().getName() + "办理业务");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                threadPool.shutdown();
            }
        }
    }

**输出：**

> **pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-1办理业务**

**3、Executors.newFixedThreadPool(6)**

**执行长期的任务，性能好很多**

**创建一个定长线程池，可控制线程最大并发数，超出的线程回在队列中等待。**

newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是想到等的，他使用的是LinkedBlockingQueue

public class ThreadPoolDemo {
        public static void main(String[] args) {
            ExecutorService threadPool = Executors.newFixedThreadPool(6);
    
            try {
                for (int i = 0; i < 10; i++) {
                    threadPool.execute(() -> {
                        System.out.println(Thread.currentThread().getName() + "办理业务");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                threadPool.shutdown();
            }
        }
    }

> pool-1-thread-5办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-3办理业务  
> pool-1-thread-4办理业务  
> pool-1-thread-2办理业务  
> pool-1-thread-3办理业务  
> pool-1-thread-1办理业务  
> pool-1-thread-5办理业务  
> pool-1-thread-6办理业务

** 补充：**

一般来说，CachedTheadPool在程序执行过程中通常会创建与所需数量相同的线程，然后在它回收旧线程时停止创建新线程，因此它是合理的Executor的首选，只有当这种方式会引发问题时（比如需要大量长时间面向连接的线程时），才需要考虑用FixedThreadPool。（该段话摘自《Thinking in Java》第四版）

### 线程池的几个重要参数介绍 ###

**源码：**

/**
         * Creates a new {@code ThreadPoolExecutor} with the given initial
         * parameters.
         *
         * @param corePoolSize the number of threads to keep in the pool, even
         *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
         * @param maximumPoolSize the maximum number of threads to allow in the
         *        pool
         * @param keepAliveTime when the number of threads is greater than
         *        the core, this is the maximum time that excess idle threads
         *        will wait for new tasks before terminating.
         * @param unit the time unit for the {@code keepAliveTime} argument
         * @param workQueue the queue to use for holding tasks before they are
         *        executed.  This queue will hold only the {@code Runnable}
         *        tasks submitted by the {@code execute} method.
         * @param threadFactory the factory to use when the executor
         *        creates a new thread
         * @param handler the handler to use when execution is blocked
         *        because the thread bounds and queue capacities are reached
         * @throws IllegalArgumentException if one of the following holds:<br>
         *         {@code corePoolSize < 0}<br>
         *         {@code keepAliveTime < 0}<br>
         *         {@code maximumPoolSize <= 0}<br>
         *         {@code maximumPoolSize < corePoolSize}
         * @throws NullPointerException if {@code workQueue}
         *         or {@code threadFactory} or {@code handler} is null
         */
        public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) {public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

** 详解：**

>   
>    1. corePoolSize ：线程池中常驻核心线程数
> 
>  
> 
>       - 在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务  
>       - 当线程池的线程数达到corePoolSize后，就会把到达的任务放到缓存队列当中
> 
>    2. maximumPoolSize：线程池能够容纳同时执行的最大线程数，必须大于等于1
> 
>  
> 
>    3. keepAliveTime ：多余的空闲线程的存活时间
> 
>  
> 
>       - 当前线程池数量超过corePoolSize时，档口空闲时间达到keepAliveTime值时，多余空闲线程会被销毁到只剩下corePoolSize个线程为止
> 
>    4. unit：keepAliveTime的单位
> 
>  
> 
>    5. workQueue：任务队列，被提交但尚未被执行的任务
> 
>  
> 
>    6. threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可
> 
>  
> 
>    7. handler：拒绝策略，表示当队列满了并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时如何来拒绝请求执行的runable的策略

### 线程池的底层工作原理 ###

**==流程==**

1.  在创建了线程池之后，等待提交过来的任务请求。
2.  当调用execute()方法添加一个请求任务时，线程池会做出如下判断
    
    2.1 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
    
    2.2 如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；
    
    2.3如果此时队列满了且运行的线程数小于maximumPoolSize，那么还是要创建非核心线程立刻运行此任务
    
    2.4如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么启动饱和拒绝策略来执行
3.  当一个线程完成任务时，他会从队列中却下一个任务来执行
4.  当一个线程无事可做超过一定的时间（keepAliveTime）时，线程池会判断：
    
    如果当前运行的线程数大于corePoolSize，那么这个线程会被停掉；所以线程池的所有任务完成后他最大会收缩到corePoolSize的大小

### 生产上如何合理设置线程池参数 ###

**补充面试题：**在工作中单一的/固定数的/可变的三种创建线程池的方法，用哪个多？

**一个都不用，我们生产上只能使用自定义的！！！！**

为什么？

线程池不允许使用Executors创建，试试通过ThreadPoolExecutor的方式，规避资源耗尽风险。

FixedThreadPool和SingleThreadPool允许请求队列长度为Integer.MAX\_VALUE，可能会堆积大量请求；

CachedThreadPool和ScheduledThreadPool允许的创建线程数量为Integer.MAX\_VALUE，可能会创建大量线程，导致OOM

### 自定义线程池  ###

/**
     * @ClassName: MyThreadPool
     * @description: 手写一个线程池
     * @author: XZQ
     * @create: 2020/2/29 10:14
     **/
    public class MyThreadPool {
        public static void main(String[] args) {
            ExecutorService threadPool =
                    new ThreadPoolExecutor(
                            2,
                            5,
                            1,
                            TimeUnit.SECONDS,
                            new LinkedBlockingDeque<Runnable>(3),
                            Executors.defaultThreadFactory(),
                            new ThreadPoolExecutor.AbortPolicy());
    
            try {
                for (int i = 0; i < 10; i++) {
                    threadPool.execute(() -> {
                        System.out.println(Thread.currentThread().getName() + "办理业务");
                    });
                }
            } catch (Exception e) {
                e.printStackTrace()
            } finally {
                threadPool.shutdown();
            }
        }
    }

### 线程池的拒绝策略 ###

1.  什么是线程策略
    
    等待队列也已经排满了，再也塞不下新任务了，同时线程池中的max线程也达到了，无法继续为新任务服务。这时我们就需要拒绝策略机制合理的处理这个问题。
2.  JDK内置的拒绝策略
    
     *  AbortPolicy(默认)
        
        直接抛出RejectedExecutionException异常阻止系统正常运行
     *  CallerRunsPolicy
        
        ”调用者运行“一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量
     *  DiscardOldestPolicy
        
        抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
     *  DiscardPolicy
        
        直接丢弃任务，不予任何处理也不抛异常。如果允许任务丢失，这是最好的一种方案
3.  均实现了RejectedExecutionHandler接口

### 面试题:合理配置线程池你是如何考虑的？ ###

1.  **CPU密集型**
    
    CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行
    
    CPU密集任务只有在真正多核CPU上才可能得到加速（通过多线程）
    
    而在单核CPU上，无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些
    
    CPU密集型任务配置尽可能少的线程数量：
    
    ==**一般公式：CPU核数+1个线程的线程池**==
2.  **IO密集型**
    
     *  由于IO密集型任务线程并不是一直在执行任务，则应配置经可能多的线程，如CPU核数 \* 2
     *  IO密集型，即该任务需要大量的IO，即大量的阻塞。
        
        在单线程上运行IO密集型的任务会导致浪费大量的 CPU运算能力浪费在等待。
        
        所以在IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
        
        IO密集型时，大部分线程都阻塞，故需要多配置线程数：
        
        参考公式：==CPU核数/（1-阻塞系数） 阻塞系数在0.8~0.9之间==
        
        八核CPU：8/（1-0，9）=80

**推荐:**

[深入理解ConcurrentModificationException并发修改异常][ConcurrentModificationException]

[大厂面试题，两个线程相互通信的多种方法][Link 1]

[手写一个快速排序算法][Link 2]

[Docker入门][Docker]

[什么是缓存穿透、缓存击穿、缓存雪崩？如何预防？][Link 3]

[ConcurrentModificationException]: https://blog.csdn.net/qq_42107430/article/details/105153433
[Link 1]: https://blog.csdn.net/qq_42107430/article/details/104885578
[Link 2]: https://blog.csdn.net/qq_42107430/article/details/104929788
[Docker]: https://blog.csdn.net/qq_42107430/article/details/104648063
[Link 3]: https://blog.csdn.net/qq_42107430/article/details/104938236