一、相关概念

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

【Java基础】线程相关基础知识

一、相关概念

1.1 cpu

1.2 cpu核心数和线程数

1.3 CPU时间片轮转机制

1.4 进程和线程

1.5 进程和线程的区别

1.6 并行和并发

1.7 高并发的意义和注意事项

1.8 线程的优先级

1.9 守护线程 & 用户线程

1.10 为什么需要多线程

1.11 并发出现问题的根源: 并发三要素

二、线程状态

三、线程创建停止方式

3.1 线程创建

3.1.1 extends Thread。

3.1.2 implements Runnable

3.1.3 implements Callable

3.1.4 通过线程池方式创建好线程

3.2 线程停止

热门文章

最新文章

相关课程

相关电子书

相关实验场景

【Java基础】线程相关基础知识

一、相关概念

1.1 cpu

1.2 cpu核心数和线程数

1.3 CPU时间片轮转机制

1.4 进程和线程

1.5 进程和线程的区别

1.6 并行和并发

1.7 高并发的意义和注意事项

1.8 线程的优先级

1.9 守护线程 & 用户线程

1.10 为什么需要多线程

1.11 并发出现问题的根源: 并发三要素

二、线程状态

三、线程创建 停止方式

3.1 线程创建

3.1.1 extends Thread。

3.1.2 implements Runnable

3.1.3 implements Callable

3.1.4 通过线程池方式创建好线程

3.2 线程停止

热门文章

最新文章

相关课程

相关电子书

相关实验场景

三、线程创建停止方式