1. 概念
程序的并发和并行 ：
- 并发：指两个或多个事件在同一个时间段内发生
- 并行：指两个或多个事件在同一时刻发生（同时发生）。
在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每 一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分 时交替运行的时间是非常短的。
而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行， 即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核 越多，并行处理的程序越多，能大大的提高电脑运行的效率。
所以，单核处理器的计算机肯定是不能并行的处理的，只能是多个任务在单个CPU上并发运行。
同理,线程也是一样的，从宏观角度上理解多线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个 线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为 线程调度。
线程与进程
- 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多 个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创 建、运行到消亡的过程。
- 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程 中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
2. 创建线程
Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是 完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。
创建线程共有两种方式，一种是继承Thread类方式，一种是实现Runnable接口方式。
1.继承Thread类：
public class MyThread extends Thread {
//重写run方法，完成该线程执行的逻辑
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName()+"：正在执行！"+i);
}
}
}
public class Demo01 {
public static void main(String[] args) {
//创建自定义线程对象
MyThread mt = new MyThread();
//开启新线程
mt.start();
}
}
2.实现Runnable接口
public class MyRunnable implements Runable {
//重写run方法
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(getName()+"：正在执行！"+i);
}
}
}
public class Demo02 {
public static void main(String[] args) {
//创建自定义类对象 线程任务对象
MyRunnable mr = new MyRunnable();
//创建线程对象
Thread t = new Thread(mr, "小强");
//开启新线程
t.start();
}
}
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的
实现Runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同一个资源。
- 使用Thread则需要继承，而Runnable可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
3. 线程安全
如果有多个线程在同时运行，而这些线程可能会同时操作同一个变量，当程序每次运行时因为线程的调度，读写频繁导致该变量不同步，这就是线程不安全。若每个线程中对全局变量、静态变量只有读操作，而无写 操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，
java 中提供了同步机制 （synchronized） 来解决
同步代码块
synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
synchronized(同步锁){
需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
- 锁对象 可以是任意类型。 (不建议使用String ，Integer Double等基本类型包装类，缓存问题)
- 多个线程对象 要使用同一把锁。
同步方法：
public synchronized void method(){
可能会产生线程安全问题的代码
}
那么此时锁对象又是谁呢
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。
Lock锁
java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
4. 线程状态
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中， 有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：
| 线程状态 | 导致状态发生条件 |
|---|---|
| NEW(新建) | 线程刚被创建，但是并未启动。还没调用start方法。 |
| Runnable(可 运行) | 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操 作系统处理器。 |
| Blocked(锁阻 塞) | 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状 态；当该线程持有锁时，该线程将变成Runnable状态。 |
| Waiting(无限 等待) | 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个 状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。 |
| Timed Waiting(计时 等待) | 同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、 Object.wait。 |
| Teminated(被 终止) | 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。 |
下面是 线程生命周期的全过程
5. 线程池
我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：
如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间。
那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？
在Java中可以通过线程池来达到这样的效果
概念： 就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作， 无需反复创建线程而消耗过多资源。
运行概念图：
合理利用线程池能够带来三个好处：
- 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
- 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
- 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内 存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
使用：
Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程 池，而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。
要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优 的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。
常用方法：
public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线 程池,也就是池中的线程个数可以指定最大数量)
获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：
public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并提交自定义的运行任务，并执行
但是在实际使用中建议手动创建线程池，可以更加明确线程池的运行状态，规避资源浪费
以 ThreadPoolExecutor为例
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
上面是 该线程池的 基本构造函数，下面介绍每个参数的含义
1.corePoolSize ：核心线程数。 当线程池创建完毕时，线程池中并没有任何的线程（可以调用prestartAllCoreThreads 或者prestartCoreThread 方法默认初始化），等待任务到来才创建线程去执行任务 ，而当线程池中的线程数达到 该数目后，新来的任务将会放到 缓存队列等待执行，也就是那个workQueue
2.maximumPoolSize ：最大线程数 ，线程池中的最大线程数。表示线程池中最多可以创建多少个线程 ，当核心线程数全部占满，并且 workQueue 队列也放不下 任务时，将会考虑创建额外的线程去执行任务，此时 如果 线程数小于maximumPoolSize 数时，将会创建 额外线程，否则将调用预先设定的策略来拒绝这个任务。
额外创建的任务又被称为“Idle Thread”空闲线程，如果这些线程空闲时间超过 最大存活时间（keepAliveTime ） 将会被回收
3.keepAliveTime ： 上面提到过，控制额外创建的线程的空闲时间，超时将会被回收
4.unit：
参数keepAliveTime的时间单位,枚举类型
TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
5.workQueue ：
阻塞队列。若新增任务时，核心线程数已经被占满，会尝试将其添加到该队列当中，只要超过了 corePoolSize 就会把任务添加到该缓存队列，如果成功的话就会等待空闲线程去执行该任务，若添加失败(一般是队列已满)，就会根据当前线程池的状态决定如何处理该任务(根据maximumPoolSize 数决定是新增额外的线程 还是调用拒绝策略)。
常用队列：
ArrayBlockingQueue //基于数组的先进先出队列，此队列创建时必须指定大小；
LinkedBlockingQueue //基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
synchronousQueue //它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。
6.threadFactory : 线程工厂，用来创建线程，可以自定义，对线程进行操作（起名字）的，当不指定时，内部会调用Executors.defaultThreadFactory()创建默认的线程工厂
7.handler ： 拒绝执行策略。 当缓存队列已满，又无法创建额外线程时，调用此策略
常用策略：
ThreadPoolExecutor.AbortPolicy: // 丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy： // 也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy： // 丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy： // 由调用线程处理该任务