☘️一. 什么是线程
每一个线程都是一个执行流，都按照自己的顺序执行自己的代码，多个线程之间“同时” （并发并行） 的执行多份代码。Java中的线程是以轻量级进程来实现的
🍒Java中，线程既然是以轻量级进程实现的，那它也具有进程的特征：
需要系统调度CPU来执行
并发：一个CPU以时间调度轮转的方式依次执行每个线程
并行：多个CPU在同一时间同时执行多个线程
🍓线程存在的必要性？
单核CPU发展遇到了瓶颈， 要想提高运算力，就得用到多核CPU， 与此同时，并发编程更能充分利用多核CPU资源
对于某些任务场景，比如等待IO，为了在等待IO的时间内做一些其他事情，也需要用到并发编程
🍅多进程也能实现并发编程，但是线程比进程轻量：
🍁创建线程比创建进程更快
🍁销毁线程比销毁进程更快
🍁调度线程比调度进程更快
🌿二. 线程和进程的区别（面试常问）
🍂进程是包含线程的，而且每一个进程至少包含一个线程（主线程）
🍂进程是系统分配资源的最小单位（基本单位），线程是操作系统调度CPU执行的最小单位（基本单位）
🍂进程状态的改变会消耗很多资源时间，线程的效率更高
🍂进程独占虚拟内存空间，一个进程包含的多个线程可以共享进程的内存
🍂一个进程要访问另一个进程的数据需要使用通信的方式，一个进程的多个线程可以使用共享变量
🍂一个进程如果挂掉是不会影响其他进程的，但是如果一个线程挂掉可能影响整个进程
👁🗨️例如：一个线程申请的内存太多超出整个进程的内存（OOM）
🍄三. 线程的创建方式（面试常问）
这里介绍两种创建方式：
· 继承Thread类， this表示当前线程对象的引用
· 实现Runnable接口，this表示的是MyRunnable的引用，当前线程的引用需要使用Thread.currentThread()
🌴1. 继承Thread类
public class Method1 { public static void main(String[] args) { MyThread t1 = new MyThread(); //创建MyThread的实例 t1.start(); //调用start方法，才会真正创建操作系统中的线程，并申请系统调度执行 } public static class MyThread extends Thread { //必须重写run方法描述线程要执行的任务 @Override public void run() { System.out.println("创建方式1"); } } }
🌵2. 实现Runnable接口
public class Method2 { public static void main(String[] args) { //先创建Runnable对象，然后当作参数传入Thread的构造方法中 Thread t2 = new Thread(new MyRunnable()); t2.start(); } //Runnable接口，表示定义线程任务对象（Thread才是线程本身） public static class MyRunnable implements Runnable { @Override public void run() { System.out.println("创建方式2"); } } }
🌾3. 变形的方式创建
🍀使用匿名内部类来创建Thread子类对象
public class Method3 { public static void main(String[] args) { Thread t3 = new Thread() { @Override public void run() { System.out.println("匿名内部类创建Thread子类对象"); } }; t3.start(); } }
🍀使用匿名内部类来创建Runnable子类对象
public class Method4 { public static void main(String[] args) { Thread t4 = new Thread(new Runnable() { @Override public void run() { System.out.println("使用匿名内部类创建Runnable子类对象"); } }); t4.start(); } }
🍀lambda表达式创建Runnable子类对象
public class Method5 { public static void main(String[] args) { Thread t5 = new Thread(() -> System.out.println("lambda表达式创建")); t5.start(); } }
🌻四. Thread常用方法
🍖1. Thread常见构造方法
| 方法 | 说明 |
| Thread() | 创建线程对象 |
| Thread(Runnable target) | 使用Runnable对象创建线程对象 |
| Thread(String name) | 创建线程对象并命名 |
| Thread(Runnable target,String name) | 使用Runnable对象创建线程对象并命名 |
Thread t1 = new Thread(); Thread t2 = new Thread(new MyRunnable()); Thread t3 = new Thread("名字1"); Thread t4 = new Thread(new MyRunnable(),"名字2");
🍗2. Thread的常见属性
| 属性 | 获取方法 |
| ID | getId() |
| 名称 | getName() |
| 状态 | getState() |
| 优先级 | getPriority() |
| 是否有后台线程 | isDaemon() |
| 是否存活 | isAlive() |
| 是否被中断 | isInterrupted() |
👁🗨️说明：
🍃ID：是线程的唯一标识，多个线程不能重复
🍃名称：是线程的名称
🍃状态：表示线程所处的情况
🍃优先级：理论来说，优先级高的线程优先被调度到
🍃后台线程：JVM会在一个进程的所有非后台线程结束后，才会结束运行
🍃是否存活：简单理解为run方法是否运行结束
🍃中断：下面板块中介绍
🥩3. 介绍说明常用方法
Thread有静态方法也有实例方法：
Thread.静态方法()
thread对象.实例方法()
线程中断（重点掌握）
实现线程中断的操作：设置一个标记位，表示是否被中断，线程在执行时循环判断是否被中断
public class Interrupt { private static boolean isStop = false; //标记位 public static void main(String[] args) throws InterruptedException { Thread t = new Thread(new Runnable() { @Override public void run() { try { while(!isStop){ //每一秒钟打印一次 //如果线程处于休眠状态就不会被中断（如休眠100秒） Thread.sleep(1000); System.out.println("hello word"); } } catch (InterruptedException e) { e.printStackTrace(); } } }); t.start(); //让t线程运行3秒中在中断 Thread.sleep(3000); isStop = true; } }
Thread.interrupted()，静态方法，调用后会重置标志位，但是多个线程是共享着一起使用的，不推荐使用
重点使用这种方法：
public class Demo { public static void main(String[] args) throws InterruptedException { Thread t = new Thread(() -> { while(!Thread.currentThread().isInterrupted()){ System.out.println("执行中"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); System.out.println("执行收尾操作"); break; } } }); t.start(); Thread.sleep(3000); t.interrupt(); } }
t.interrupt()：
- t处于就绪态，调用就会将标志位设置为true
- t处于阻塞状态（sleep），调用就会触发interruptException
🌼五. 线程的状态（面试常问）
👁🗨️说明：
🍁NEW：Thread对象已经创建好了，但是还没有调用start
🍁RUNNABLE：处于就绪队列中，随时可以被调度到CPU上
🍁BLOCKED：当前线程在等待锁，导致阻塞
🍁WAITING：当前线程等待被唤醒，导致阻塞
🍁TIME_WAITING：当前线程在一定时间内，处于阻塞状态（一定时间到了之后，阻塞解除），sleep，join(时间)
🍁TERMINATED：线程已经执行完毕，销毁了，但是Thread对象还存在
❗注意：RUNNABLE包含就绪态和运行态（程序不知道线程是就绪态还是运行态，由操作系统决定）
🍎六. 线程的优点
🍬创建线程的代价比创建进程的代价小得多
🍬与进程切换相比，线程切换需要操作系统进行的工作量要小的多
🍬线程占用资源比进程少
🍬能充分利用多处理器的可并行数量
🍬在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
🍬计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
🍬I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作
