一、相关概念
1.1 cpu
中央处理器（central processing unit, 简称cpu ），计算机系统的 运算 和 控制 核心
1.2 cpu核心数和线程数
cpu核心数指cpu 内核数量，如双核、四核、八核。
cpu线程数是一种逻辑的概念，就是模拟出的cpu核心数，
核心数:线程数=1:1
使用了超线程技术后---> 1:2
时间片：分配给线程的运行时间（进程允许运行的时间），通常为 10~100ms 。
1.3 CPU时间片轮转机制
又称RR调度，用于分时系统中的进程调度。
为了实现轮转调度，系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。 每当执行进程调度时，进程调度程序总是选出就绪队列的队首进程，让它在 CPU 上运行一个时间片的时间。
当进程用完分给它的时间片后，系统的计时器发出时钟中断，调度程序便停止该进程的运行，把它放入就绪队列的末尾； 然后，把 CPU 分给就绪队列的队首进程，同样也让它运行一个时间片， 如此往复。 会导致上下文切换。
1.4 进程和线程
- 进程
程序运行资源分配的最小单位，进程内部有多个线程，会共享这个进程的资源
- 线程
CPU调度的最小单位，必须依赖进程而存在。
1.5 进程和线程的区别
- 从属关系：进程是正在运行程序的实例，进程包含了线程。
- 描述侧重点：进程是操作系统分配资源的基本单位，线程是操作系统调度的基本单位。
- 共享资源：多个进程不能共享资源，每个进程有自己的堆、栈、虚拟空间、文件描述等，而线程可以共享堆、方法。
- 上下文切换速度：进程比较快（从一个线程切换到另一个线程），线程会比较慢。
- 操作者：一般来说进程由系统控制，线程由程序员控制。
1.6 并行和并发
- 并行
同一时刻，可以同时处理事情的能力。
并行是指多个处理器或者是多核的处理器同时处理多个不同的任务。
- 并发
与单位时间相关，在单位时间内可以处理事情的能力。
并发是指一个处理器同时处理多个任务。
打个比方：并发是一个人同时吃三个馒头，而并行是三个人同时吃三个馒头。
1.7 高并发的意义和注意事项
- 意义
充分利用cpu的资源、加快用户响应的时间，程序模块化，异步化
- 注意事项
- 线程共享资源，存在冲突
- 容易导致死锁
- 启用太多的线程，就有搞垮机器的可能
1.8 线程的优先级
取值为1~10，缺省为5，但线程的优先级不可靠，不建议作为线程开发时候的手段
1.9 守护线程 & 用户线程
- User Thread(用户线程)
普通线程，例如普通当new Thread
- Daemon Thread(守护线程)
thread1.setDaemon(true); 也即设置了 setDaemon的线程
1.守护线程并非虚拟机内部可以提供，用户也可以自行的设定守护线程，方法：public final void setDaemon(boolean on)
2.thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。
3.你不能把正在运行的常规线程设置为守护线程。
4.守护线程中创建当线程也是守护线程。
当 JVM 中不存在任何一个正在运行的非守护线程时，则 JVM 进程即会退出， 大白话就是当主线程结束时，此时普通当用户线程会继续执行，
当所有当用户线程执行完后，即结束所有线程，此时如果还有守护线程在执行，也会立即结束。
1.10 为什么需要多线程
CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异。
- CPU 增加了缓存，以均衡与内存的速度差异；// 导致 可见性问题
- 操作系统增加了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差异；// 导致 原子性问题
- 编译程序优化指令执行次序，使得缓存能够得到更加合理地利用。// 导致 有序性问题
1.11 并发出现问题的根源: 并发三要素
可见性是由于CPU缓存引起。
可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到。如：
//线程1执行的代码
int i = 0;
i = 10;
//线程2执行的代码
j = i;
假若执行线程1的是CPU1，执行线程2的是CPU2。由上面的分析可知，当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。
此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.
原子性问题是分时复用引起。
原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
如：
int i = 1;
// 线程1执行
i += 1;
// 线程2执行
i += 1;
1. 将变量 i 从内存读取到 CPU寄存器；
2. 在CPU寄存器中执行 i + 1 操作；
3. 将最后的结果i写入内存（缓存机制导致可能写入的是 CPU 缓存而不是内存）。
由于CPU分时复用（线程切换）的存在，线程1执行了第一条指令后，就切换到线程2执行，假如线程2执行了这三条指令后，再切换会线程1执行后续两条指令，将造成最后写到内存中的i值是2而不是3。
有序性问题是重排序引起。
int i = 0;
boolean flag = false;
i = 1; //语句1
flag = true; //语句2
二、线程状态
1. 新建状态(New): 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。 例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4. 阻塞状态(Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。
阻塞的情况分三种：
- 等待阻塞 > 通过调用线程的wait()方法，让线程等待某工作的完成。
- 同步阻塞 > 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
- 其他阻塞 > 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
6.Waiting等待状态
编辑
三、线程创建 停止方式
3.1 线程创建
从JDK 5开始，把工作单元与执行机制分离开来，工作单元包括Runnable和Callable，而执行机制由Executor框架提供。
3.1.1 extends Thread。
由于java的单继承性，此类不可再继承其他类， 若使用runnable的方式，则可多继承，且runnable 可被多个thread共享
ExThread thread1 = new ExThread("thread1"); thread1.start(); thread 类本身就是实现runnable接口 public class Thread implements Runnable { }
3.1.2 implements Runnable
run()方法，本质还是通过new Thread实现。好处是多继承，且可资源共享。
3.1.3 implements Callable
call()方法，通过FutureTask实例对象的get方法获取执行结果。
通过callable、FutureTask、thread组合， FutureTask也实现类runnable接口。
ImplCallable callable = new ImplCallable("thread3"); FutureTask task = new FutureTask<>(callable); Thread thread1 = new Thread(task); thread1.start();
3.1.4 通过线程池方式创建好线程
事先将多个线程对象放到一个容器中，当使用的时候就不用 new 线程而是直接去池中拿线程即可，节省了开辟子线程的时间，提高的代码执行效率。 所以总结起来应该就只有new thread一种方式，
Runnable和Callable区别
Callable的 call() 方法可以返回值和抛出异常，而Runnable的run()方法没有这些功能，run的异常只能内部消化。
这两个接口最后都需要调用thread.start()方法。
FutureTask在调用get()方法时会阻塞主线程，反之，线程不会阻塞。
runnable没有返回值，而实现callable接口的任务线程能返回执行结果。
callable接口实现类中的run方法允许异常向上抛出，可以在内部处理，try catch; 但是runnable接口实现类中run方法的异常必须在内部处理，不能抛出。
public interface Callable V> { V call() throws Exception; } public interface Runnable { public abstract void run(); }
thread的start()和run()方法有什么区别
start()方法被用来启动新创建的线程，而且start()内部调用了run()方法 ，
用start方法来启动线程，真正启动来一个新的线程，在start方法调用后，会继续执行下面的代码，例如： 下面start方法调用后，会立马执行后面的日志输出
thread1.start();
Log.d("xyz", "threadName");
调用start方法后，此时线程处于就绪状态，并没有真正运行，线程被放到操作系统的任务等待队列，等待cpu调度，然后通过jvm，最后会调用到thread的run方法。
调用run()方法的时候，只会是在原来的线程中调用，没有新的线程启动，
start()方法会启动新线程，当一个线程启动之后，不能重复调用start()，否则会报IllegalStateException异常。
run方法就是一个普通的方法，如果直接调用，就是运行在调用的线程中。
线程是不是越多越好
CPU密集型任务，并行执行的线程数应该尽量和CPU核心数保持一致，否则超过了CPU核心数，再提高线程数也不会提高处理速度，反而因为上下文切换带来的损耗降低处理速度。对于I/O密集型任务，根据I/O的响应速度，适当地调节线程数目，可以提高系统速度。
3.2 线程停止
java线程的终止，可以让线程运行完自动终止，也可以在运行过程中主动停止，通过添加退出标记。
new Thread(new Runnable() { private volatile boolean exit=false; @Override public void run() { while(!exit){ //执行业务逻辑 } } }).start();
java线程是协作式，而非抢占式。
