一、相关概念

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线程是协作式，而非抢占式。