什么是线程，什么是进程
进程：进程就是正在执行的程序。
线程：是程序执行的一条路径, 一个进程中可以包含多条线程。 通俗理解：例如你打开微信就是打开一个进程，在微信里面和好友视频聊天就是开启了一条线程。
两者之间的关系： 一个进程里面可以有多条线程，至少有一条线程。 一条线程一定会在一个进程里面。
创建线程的三种方式
一、继承Thread
1、定义一个类MyThread继承Thread，并重写run方法。
2、将要执行的代码写在run方法中。
3、创建该类的实例，并调用start()方法开启线程。
二、实现Runnable接口
1、定义一个类MyRunnable实现Runnable接口，并重写run方法。
2、将要执行的代码写在run方法中。
3、创建Thread对象, 传入MyRunnable的实例，并调用start()方法开启线程。
三、实现 Callable 接口
Callable 是类似于 Runnable 的接口，实现 Callable 接口的类和实现 Runnable 的类都是可被其它线程执行的任务。
1、自定义一个类 MyCallable 实现 Callable 接口，并重写call()方法
2、将要执行的代码写在call()方法中
3、创建线程池对象，调用submit()方法执行MyCallable任务，并返回Future对象
4、调用Future对象的get()方法获取call()方法执行完后的值
四、三种创建方式对比
继承 Thread 类与实现 Runnable 接口的区别：
我们都知道 java 支持单继承，多实现。实现 Runnable 接口还可以继承其他类，而使用继承 Thread 就不能继承其他类了。所以当你想创建一个线程又希望继承其他类的时候就该选择实现 Runnable 接口的方式。
实现 Callable 接口与 Runnable 接口的区别：
Callable 执行的方法是 call() ，而 Runnable 执行的方法是 run()。 call() 方法有返回值还能抛出异常， run() 方法则没有没有返回值，也不能抛出异常。
什么是多线程
一、基本定义
一个进程中定义了多个线程
二、为什么要使用多线程
提高CPU的使用率
例如朋友圈发表图片，当你上传9张图片的时候，如果开启一个线程用同步的方式一张张上传图片，假设每次上传图片的线程只占用了CPU 1%d的资源，剩下的99%资源就浪费了。但是如果你开启9个线程同时上传图片，CPU就可以使用9%的资源了。
2、提高程序的工作效率
还是拿朋友圈发表图片来说，假设开启一个线程上传一张图片的时间是1秒，那么同步的方式上传9张就需要9秒，但是你开启9个线程同时上传图片，那么就只需要1秒就完成了。
三、多线程有什么缺点
如果有大量的线程,会影响性能,因为CPU需要在它们之间切换。
更多的线程需要更多的内存空间。
多线程操作可能会出现线程安全或者死锁等问题。
四、并发与并行
概念
并行：多个处理器或者多核处理器同时执行多个不同的任务。
并发：一个处理器处理多个任务。
打个比喻
并行就是一个人用他的左手喂女儿吃饭，同时用右手喂儿子吃饭。
并发就是一个人先喂女儿吃一口饭，接着喂儿子吃一口，然后再喂女儿吃一口，轮流喂。
线程池
一、概念：
一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度
二、为什么使用线程池
1、减少创建与销毁线程带来的性能开销。
2、可控制最大并发线程数，避免过多资源竞争而导致系统内存消耗完。
3、能更好的控制线程的开启与回收，并且能定时执行任务。
线程池ThreadPoolExecutor
既然Android中线程池来自于Java，那么研究Android线程池其实也可以说是研究Java中的线程池
在Java中，线程池的概念是Executor这个接口，具体实现为ThreadPoolExecutor类，学习Java中的线程池，就可以直接学习他了
对线程池的配置，就是对ThreadPoolExecutor构造函数的参数的配置，既然这些参数这么重要，就来看看构造函数的各个参数吧
ThreadPoolExecutor提供了四个构造函数
//五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue)
//六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory)
//六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
RejectedExecutionHandler handler)
//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
我知道你看到这些构造函数和我一样也是吓呆了，但其实一共就7种类型，理解起来简直和理解一周有7天一样简单，而且一周有两天是周末，其实也就只有5天需要了解！相信我，毕竟扯皮，我比较擅长
int corePoolSize => 该线程池中核心线程数最大值
核心线程：
线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程
核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。
如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉
很好理解吧，正常情况下你不干活我也养你，因为我总有用到你的时候，但有时候特殊情况(比如我自己都养不起了)，那你不干活我就要把你干掉了
int maximumPoolSize
该线程池中线程总数最大值
线程总数 = 核心线程数 + 非核心线程数。核心线程在上面解释过了，这里说下非核心线程：
不是核心线程的线程(别激动，把刀放下...)，其实在上面解释过了
long keepAliveTime
该线程池中非核心线程闲置超时时长
一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉
如果设置allowCoreThreadTimeOut = true，则会作用于核心线程
TimeUnit unit
keepAliveTime的单位，TimeUnit是一个枚举类型，其包括：
NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MICROSECONDS ： 1微秒 = 1毫秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ： 秒
MINUTES ： 分
HOURS ： 小时
DAYS ： 天
BlockingQueue workQueue
该线程池中的任务队列：维护着等待执行的Runnable对象
当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务
常用的workQueue类型：
SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务
ThreadFactory threadFactory
创建线程的方式，这是一个接口，你new他的时候需要实现他的Thread newThread(Runnable r)方法，一般用不上，这是星期六，休息
但我还是说一句吧(把枪放下...)
小伙伴应该知道AsyncTask是对线程池的封装吧？那就直接放一个AsyncTask新建线程池的threadFactory参数源码吧：
new ThreadFactory() {
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread new Thread(Runnable r) {
return new Thread(r,"AsyncTask #" + mCount.getAndIncrement());
}
}
这么简单？就给线程起了个名？！对啊，所以说这是星期六啊，别管他了，虽然我已经强迫你们看完了...
RejectedExecutionHandler handler
这玩意儿就是抛出异常专用的，比如上面提到的两个错误发生了，就会由这个handler抛出异常，你不指定他也有个默认的
抛异常能抛出什么花样来？所以这个星期天不管了，一边去，根本用不上
新建一个线程池的时候，一般只用5个参数的构造函数。
向ThreadPoolExecutor添加任务
那说了这么多，你可能有疑惑，我知道new一个ThreadPoolExecutor，大概知道各个参数是干嘛的，可是我new完了，怎么向线程池提交一个要执行的任务啊？
通过ThreadPoolExecutor.execute(Runnable command)方法即可向线程池内添加一个任务
ThreadPoolExecutor的策略
上面介绍参数的时候其实已经说到了ThreadPoolExecutor执行的策略，这里给总结一下，当一个任务被添加进线程池时：
线程数量未达到corePoolSize，则新建一个线程(核心线程)执行任务
线程数量达到了corePools，则将任务移入队列等待
队列已满，新建线程(非核心线程)执行任务
队列已满，总线程数又达到了maximumPoolSize，就会由上面那位星期天(RejectedExecutionHandler)抛出异常
有哪些常用的线程池，它们的应用场景是什么
newFixedThreadPool
创建固定大小的线程池，这样可以控制线程最大并发数，超出的线程会在队列中等待。如果线程池中的某个线程由于异常而结束，线程池则会再补充一条新线程。
newSingleThreadExecutor：
创建一个单线程的线程池，即这个线程池永远只有一个线程在运行，这样能保证所有任务按指定顺序来执行。如果这个线程异常结束，那么会有一个新的线程来替代它。
newCachedThreadPool：
创建带有缓存的线程池，在执行新的任务时，当线程池中有之前创建的可用线程就重用之前的线程，否则就新建一条线程。如果线程池中的线程在60秒未被使用，就会将它从线程池中移除。
newScheduledThreadPool：
创建定时和周期性执行的线程池。