进程与线程

**进程（Process）**是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及其组织形式的描述，进程是程序的实体。
**线程（thread）**是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

总的来说：
进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。
线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

打个比方：我们电脑的每一个程序都是一个进程，而程序中的某一些些的功能就可以看做是一个个线程。例如你正在谷歌浏览器上看我的这篇文章，谷歌浏览器就可以看做是一个进程。而你开的一个个小窗口就可以看做事一个个线程。

额外在补充一点：
管程(monitor)：是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现)，但是这样并不能保证进程以设计的顺序执行 JVM 中同步是基于进入和退出管程(monitor)对象实现的，每个对象都会有一个管程(monitor)对象，管程(monitor)会随着 java 对象一同创建和销毁执行线程首先要持有管程对象，然后才能执行方法，当方法完成之后会释放管程，方法在执行时候会持有管程，其他线程无法再获取同一个管程。
简单来说：你可以把管程看做是锁。

多线程的创建方式

面试经常被问到，多线程的创建方式有4种：

继承Thread，重写run方法
实现Runnable接口，重写run方法
实现Callable接口，重写call方法，再搭配FutureTask
自定义线程池

继承Thread

public class test{
    public static void main(String[] args) throws InterruptedException {
        MyThread thread1 = new MyThread();
        new Thread(thread1, "线程1").start();
    }
}

public class MyThread extends Thread{

    @Override
    public void run(){
        System.out.println("多线程1");
    }
}

这个没啥说的，我们从学习java开始就接触这种创建方式。

实现Runnable接口

public class MyThread2 implements Runnable {

    @Override
    public void run() {
        System.out.println("多线程2");
    }
}

public class test {
    public static void main(String[] args) throws InterruptedException {
        // 原始方法创建
        MyThread2 thread2 = new MyThread2();
        new Thread(thread2, "线程2").start();

        // lambda表达式
        new Thread(() -> {
            System.out.println("多线程2");
        }, "线程2").start();
    }
}

这个其实也没啥好说的，注意的是现在多数是用的lambda方式来创建的多线程。

实现Callable接口

首先来看一下这个callable，它是一个函数式接口，没有参数，但是有返回值。

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

再来看看 FutureTask ，它是一个接口，继承了 Runnable 接口。再来看看它尽然有两个构造方法，一个可以传入 Runnable ，另外一个可以传入 Callable 。

class test {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        MyThread3 thread3 = new MyThread3();
        FutureTask futureTask = new FutureTask(thread3);

        new Thread(futureTask, "多线程3").start();

        // 可以获取futureTask的返回值
        System.out.println("futureTask返回的结果：" + futureTask.get());

        // lambda表达式
        FutureTask<Integer> integerFutureTask = new FutureTask<>(() -> {
            // 有返回值
            return 2;
        });
        new Thread(integerFutureTask, "多线程3").start();
        integerFutureTask.get();
    }
}

class MyThread3 implements Callable {

    @Override
    public Object call() throws Exception {
        System.out.println("我是多线程3");
        return "多线程3";
    }
}

实现 Callable 的与前两种最大的区别就是：Callable可以返回一个值，并且 FutureTask 可以设置一个泛型，泛型的类型就是返回值的类型。需要主要的是，获取 futureTask.get() 是阻塞的。
当然，目前java已近有对 FutureTask 的升级：CompletableFuture异步编排，基本解决 FutureTask 的痛处。可以参考：JUC异步编排之CompletableFuture浅谈

自定义线程池

线程池简介

线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。
举个例子： 10 年前单核 CPU 电脑，假的多线程，像马戏团小丑玩多个球，CPU 需要来回切换。现在是多核电脑，多个线程各自跑在独立的 CPU 上，不用切换效率高。

其实们从字面就可以很好的理解，就会把很多个线程把在一个池子中，然后需要的时候从池子中去取，然后用完了再还回到池子中，方便节省开销。类似的还有数据库连接池。

线程池的优势：线程池做的工作只要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行。

主要特点：

降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
提高响应速度: 当任务到达时，任务可以不需要等待线程创建就能立即执行。
提高线程的可管理性: 线程是稀缺资源，如果无限制的创建，不仅会销耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor，Executors，
ExecutorService，ThreadPoolExecutor 这几个类。

线程池的种类与创建

** newCachedThreadPool(常用) **

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

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

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

** newFixedThreadPool(常用)**

作用：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
该线程池有如下特点：

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

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

** newSingleThreadExecutor(常用)**

作用：创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
该线程池有如下特点：

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

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

最后上代码：

public static void main(String[] args) throws InterruptedException, ExecutionException {

        /**
         * 通过 Executors 来创建线程池
         * Executors可以理解成线程相关的工具类，类似的还有 Collections
         */
        /**
         * 源码如下：
         * return new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
         */
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();

        /**
         * 源码如下：
         * return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
         */
        ExecutorService executorService2 = Executors.newFixedThreadPool(2);

        /**
         * 源码如下：
         * return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), threadFactory);
         */
        ExecutorService executorService3 = Executors.newCachedThreadPool();

        // 使用
        executorService1.execute(() -> {
            System.out.println("我是多线程-线程池");
        });

    }

看到这里，嘴角是不是已近上扬了。。那你错了。。来，，我们来看一张图:

java开发手册-嵩山版的第一章第7节明确说明禁止 Executors 来创建线程池，最好能自定义创建线程池。
好了，那我们看看刚才 ThreadPoolExecutor 后面跟的7个参数：

corePoolSize 线程池的核心线程数
maximumPoolSize 能容纳的最大线程数
keepAliveTime 空闲线程存活时间
unit 存活的时间单位
workQueue 存放提交但未执行任务的队列
threadFactory 创建线程的工厂类
handler 等待队列满后的拒绝策略

线程池中，有三个重要的参数，决定影响了拒绝策略：corePoolSize - 核心线程数，也即最小的线程数。workQueue - 阻塞队列。 maximumPoolSize -最大线程数。

当提交任务数大于 corePoolSize 的时候，会优先将任务放到 workQueue 阻塞队列中。当阻塞队列饱和后，会扩充线程池中线程数，直到达到maximumPoolSize 最大线程数配置。此时，再多余的任务，则会触发线程池的拒绝策略了。

总结一句话：当提交的任务数大于（workQueue.size() + maximumPoolSize ），就会触发线程池的拒绝策略。

然后再来说说拒绝策略：

CallerRunsPolicy: 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。一般并发比较小，性能要求不高，不允许失败。但是，由于调用者自己运行任务，如果任务提交速度过快，可能导致程序阻塞，性能效率上必然的损失较大。
AbortPolicy: 丢弃任务，并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。
DiscardPolicy: 默默丢弃无法处理的任务，不予处理也不抛出异常。如果允许任务丢失，该策略最好。
DiscardOldestPolicy: 只要线程池没有关闭的话，丢弃阻塞队列 workQueue 中最老的一个任务，并将新任务加入。

线程池底层工作流程

知道了怎么多那线程池底层到底怎么工作的呢？

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

总结

实际项目中创建多线程时，使用常见的三种线程池创建方式时，单一、可变、定长都有一定问题，原因是 FixedThreadPool 和 SingleThreadExecutor 底层都是用LinkedBlockingQueue 实现的，这个队列最大长度为 Integer.MAX_VALUE，容易导致 OOM。所以实际生产一般自己通ThreadPoolExecutor 的 7 个参数，自定义线程池。

JUC线程之线程的多种创建