目录
🌾 前言
🌾 了解线程
🌈1.1 线程是什么？
🌈1.2 一些基本问题
🌾2、创建线程的方式
🌈 2.1 继承Thread类
🌈 2.2 实现Runnable接口并重写run()方法
🌈 注意：多个线程的写法
🌾3、多线程编程的意义
🌾4、线程的类与常用方法
🌈 4.1 构造方法
🌈 4.2 Thread类的几个常见属性
🌾5、线程的状态
🌾 前言
在学习之前，我们先简单的了解一下计算机中的常见的概念。
1、冯诺依曼结构体系
现代的计算机大多遵循冯诺依曼体系结构。主要由运算器，控制器，存储器，输入设备，输出设备组成。
2、操作系统
操作系统是一组做计算机资源管理系统的统称。常见的操作系统由Windows系列，Linux系列，OSX系列，ISO系列，Android系列。操作系统的作用主要有：（1）向上为应用程序提供一个稳定的运行环境；（2）向下管理所有的硬件设备；（3）为用户提供一个人机交互的界面。
3、进程
每一个运行起来的程序(软件)，操作系统都会以进程的形式将他们管理起来。在操作系统中，每一个进程被描述为一个PCB（进程控制块抽象）。一个PCB中主要包括：PID，内存指针，文件描述符表，进程的优先级，进程的状态，上下文信息和记账信息。
CPU分配 -> 进程调度：假设大部分场景下都是单CPU单核的计算机。操作系统对于CPU资源的分配，采用的是时间模式：不同的进程在不同的时间段去使用CPU资源。
内存分配 ->内存管理：操作系统对内存资源的分配，采用的是空间模式：不同的进程使用内存中的不同区域，互相之间不会干扰。
4、虚拟内存空间
进程启动之后会申请内存空间，正常情况下是没有问题的。但是可能会出现一些特殊情况，比如C++中的野指针等。因此实际中，操作系统中有一个模块叫做MMU，MMU会给每个进程分配一个虚拟内存地址，这个地址和真实的物理内存之间建立映射关系。当进程越界访问内存空间时，MMU直接会进行拦截，起到了一个校验的作用，不会对真实的物理内存造成影响。
存在的问题：但是由于MMU的限制，导致不同进程之间不能够互相访问内存，所以如何实现进程之间的数据共享，从而达到“信息交换”的需求？针对这一问题，进程间通信的需求应运而生。目前，主流操作系统提供的进程通信机制主要有：管道，共享内存，文件，网络，信号量，信号。
问题：并发与并行的区别？
在一个处理器上不停横向的轮动叫做并发，在多个处理器上执行叫做并行。通俗解释就是：并发是：一会干这件事，一会干那件事，但其实同一时刻只能干一件事；并行是：一边干这件事，一边干那件事，在同一时刻干多件事，真正意义上的同时进行，在编程方面，我们统一称为并发编程。
🌾 了解线程
🌈1.1 线程是什么？
一般多进程用来处理一个很大或者很复杂的任务。当进程启动的时候，需要申请内存，申请文件资源，将PCB加入到链表中；当进程结束的时候，需要释放文件，释放内存，从链表中删除PCB。但是在这个过程中申请和释放资源的操作是十分耗时的。因此为了解决资源消耗的问题，提出了一个轻量级进程的概念（线程）。在创建线程的时候使用的是进程创建时申请到的所有资源，线程只需要关注要处理的任务即可。
举个例子：比如张三设计了一些皮包，他要去开一个工厂。他需要做以下一些事情：、
（1）去工业园区申请地皮，水电，仓库等(花了一个月的时间和几十万的钱)；
（2）修建厂房和基础设施（花了几个月和几十万的钱）；
（3）购买生产设备和原材料，招工（花了一周和几万块钱）；
（4）开始生产。
主要关注两者之间的对应关系！
🌈1.2 一些基本问题
❓ 问题1：进程与线程之间的区别？（面试题）
（1）对于一个进程而言，必然会有一个线程（主线程）；
（2）进程是申请系统资源的最小单位，线程是CPU调度的最小单位；
（3）进程之间互不影响，线程使用的是进程统一申请来的资源，线程之间可以相互影响。
❓ 问题2： 使用多线程编程的原因？
（1）为了充分利用CPU的资源
（2）利用轻量级进程的特性来减少系统性能的开销:
线程创建的效率比进程高;
线程销毁的效率比进程高；
线程调度的效率比进程高
❓ 问题3：使用多线程存在的问题？
当线程数量增大到一定程度之后，可能会给CPU调度带来负担，出现资源抢夺的问题，就会出现一些线程不安全的现象。
🌾2、创建线程的方式
🌈 2.1 继承Thread类
三部曲：继承Thread来创建一个线程类 -> 创建MyThread的实例 -> 使用start()方法启动线程
(1)正常写法
public class Demo1_createThread {
public static void main(String[] args) {
Thread t = new MyThread();
t.start();
while (true){
System.out.println("main thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
class MyThread extends Thread{
@Override
public void run() {
while (true){
System.out.println("这里是线程运行的代码");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}（2）使用匿名内部类的写法
public static void main(String[] args) {
//匿名内部类的形式
Thread t = new Thread(){
@Override
public void run() {
while (true){
System.out.println("生产生产生产...金币金币金币...+1+1+1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
//启动进程
t.start();
}🌈 2.2 实现Runnable接口并重写run()方法
三部曲：实现Runnable接口 -> 创建Thread类实例，将Runnable对象作为其目标参数 -> 使用start()方法启动线程
注意:在调用start()方法后，JVM会调用系统API，并在系统中生成一个PCB来执行run()方法中的代码。
（1）正常写法
public class Demo2_createRunnable {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t = new Thread(myRunnable);
t.start();
while (true){
System.out.println("main thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
while (true){
System.out.println("这是线程运行的代码");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}注意：两个线程并不是有序的交替运行，因为CPU的调度是随机的。线程的执行是“抢占式执行”。
（2）使用匿名内部类的写法
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
while (true){
System.out.println("生产皮包，金币+1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
//开启线程
t.start();
}（3）使用Lambda写法
public static void main(String[] args) {
//Lambda表达式的使用条件就是该接口必须是一个函数式接口
//比如Runnable接口就是一个 FunctionalInterface：所谓的函数式接口就是里面只有一个方法。比如(Runnable接口)中只有一个run();
//怎么用Lambda表达式呢？()里写run方法的所有参数名，不需要参数类型，然后一个->即可。后面是正常的函数的功能实现
Thread t = new Thread(()->{
while (true){
System.out.println("生产皮包，金币+1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
//开启线程
t.start();
}❓ 问题：使用Runnable 定义任务的好处？
（1）解耦，将定义线程与定义任务分开。（其中解耦的意思就是将不同的功能都给分开，如果要修改或者查找相应的功能的时候可以在指定的位置找）
（2）将创建线程与定义任务分开，以便修改代码时，可以统一修改。
🌈 注意：多个线程的写法
public class Demo3_multiRunnable {
public static void main(String[] args) {
//创建任务的对象
MyRunnable1 myrunnable1 = new MyRunnable1();
MyRunnable2 myrunnable2 = new MyRunnable2();
//创建生产皮包的线程
Thread t1 = new Thread(myrunnable1);
Thread t2 = new Thread(myrunnable1);
//创建生产皮鞋的线程
Thread t3 = new Thread(myrunnable2);
//启动线程
t1.start();
t2.start();
t3.start();
}
}
//描述生产皮包的任务
class MyRunnable1 implements Runnable{
@Override
public void run() {
System.out.println("生产皮包，金币+1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
//描述生产皮鞋的任务
class MyRunnable2 implements Runnable{
@Override
public void run() {
System.out.println("生产皮鞋，金币+1");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}🌾3、多线程编程的意义
使用多线程编程主要是为了充分利用CPU资源，提高程序的运行效率。
🌰：现在我们分别对两个变量进行10亿次的自增，分别使用两种方式：串行和并行。观察一下它们之间的时间差异。理论上来讲，并行应该是串行时间的一半。接下来我们俩看一下实际上是不是这样~
结论：从上可以看出并行时间确实小于串行时间，但并不是严格意义上的一半，这主要是因为每创建一个线程都是要消耗时间和资源的。同样的，我们将计算量变小一些，可以看到反而串行时间小于并行时间。因此我们要知道并不是所有的场景下使用多线程第一可以提升效率，具体是否需要使用多线程主要根据计算量来决定。
🌾4、线程的类与常用方法
🌈 4.1 构造方法
Thread类是JVM用来管理线程的一个类。
🌈 4.2 Thread类的几个常见属性
（1） 获取线程名：Thread.currentThread().getName();
（2）是否后台线程：isDaemon()
isDaemon() 默认为false（前台线程），如果要创建后台线程则传入true，手动设置为后台线程。其中在main方法结束之后，线程会自动结束。
❓ 问题：前台线程与后台线程的区别？
应用程度的主线程以及使用new Thread方式构造的线程都默认是前台线程。通过BeginXXX方法运行的线程都是后台线程，托管线程池中的线程都是后台线程。
前台线程与后台线程的主要区别就是：进程会等待所有的前台线程完成后再结束工作，但是如果只剩下后台线程，则会直接结束工作。如果程序定义了一个不会完成的前台线程，主程序不会正常结束。
比如银行转账的业务，一定要用前台线程；统计微信步数这种处理容错率比较高的业务或者辅助功能等，就可以使用后台线程。
后台线程演示：
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
while (true){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
//第一次：在线程启动之前 设置线程为后台,观察线程的存活状态
thread.setDaemon(true);
System.out.println("在线程start之前设置为后台线程，此时的存活状态是："+ thread.isAlive());
//启动线程
thread.start();
//此时休眠是因为start之后，系统要去创建PCB，给系统一点时间能够创建成功
Thread.sleep(2000);
//第二次：在start线程之后，观察线程的存活状态
System.out.println("在线程start之后观察线程的存活状态："+thread.isAlive());
System.out.println("main线程执行完成");
System.out.println("此时线程是否存活:"+thread.isAlive());
}
（3）是否存活 isAlive()指的是系统的线程PCB是否存活，并不是说我们new出来的Thread对象。
（4）是否被中断：停止或者终止当前现成的任务
方式1：通过设置中断标识:主要注意代码中的while(!isQuit) 和 isQuit = true这两点。
方式2：通过调用Thread类提供的interruped()方法来中断线程。isInterrupted()默认为false不中断。
注意看下面的写法：有两处改动，但是会抛出异常。
这主要是因为上面的两处改动都针对的是runnable状态中的异常处理，所以我们还要对 Sleep状态做处理：在catch中处理：有三种方式：
（5）等待一个线程 join()：等待线程结束
（6）获取当前线程引用：Thread thread = Thread.currentThread();
（7）start()方法
❓ 问题：start()方法与run()方法的区别？（面试题）
start()：申请一个真正的系统线程run() :定义线程要执行的任务。
直接调用run方法，并不会去申请一个真正的系统线程(PCB)，只是一个普通的方法调用，是单独的调用对象的方法。调用start方法，JVM会调用本地方法去系统中真正的申请一个线程(PCB),并执行run方法中 的逻辑。
🌾5、线程的状态
注意：线程的状态指的是Thread对象（有自己的生命周期）的状态，并不是PCB的状态。主要有以下几种：
1、NEW ：java对象创建好了，但是还没有调用start方法创建PCB。
2、RUNNABLE : 就绪和运行状态。可以随时调度到CPU中执行。
3、TERMINATED: 线程任务执行完成，PCB在操作系统中已经销毁，但是java对象还存在。
4、TIMED_WATING ：等待一段时间，这个时间是有时间限制的等待（过时不候)。比如sleep()，常见的访问超时。
5、WAITING：没有时间限制的等待。
6、BLOCK：等待锁的时候进入的阻塞状态。
最后，知道 在系统中针对线程的两个调度是用两个队列来实现的。准备执行的线程在就绪队列中，随时等待CPU调度。当调用sleep,wait,join方法时，就会被移动到阻塞队列中。当休眠时间到了之后，就会被移动回就绪队列，重新参与CPU调度。
