一文看懂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 {@Overridepublic void run() {//Runable方式创建线程 具体实现}
}//启动线程new Thread(new MyThread2()).start();

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

  public Thread(Runnable target) {init(null, target, "Thread-" + nextThreadNum(), 0);}@Overridepublic 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> {@Overridepublic Integer call() throws Exception {System.out.println("**** come in ****");return 1024;}
}

输出：

**** come in ****
1024

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

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

输出：

**** 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并发修改异常

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

手写一个快速排序算法

Docker入门

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