学习笔记系列开头惯例发布一些寻亲消息
链接：https://baobeihuijia.com/bbhj/contents/3/199561.html
-
进程和线程:进程是资源分配的最小单位，线程是CPU调度的最小单位
- 进程和线程的主要区别（总结）_进程和线程的区别-CSDN博客
- 进程和线程的区别(超详细)-CSDN博客
- 在操作系统中能同时运行多个进程（程序）；而在同一个进程（程序）中有多个线程同时执行
- 一个进程中可以有多个线程，多个线程共享进程的堆和**方法区 (JDK1.8 之后的元空间)*资源，但是每个线程有自己的*程序计数器、虚拟机栈 和 本地方法栈
-
并行和并发（从cpu的角度划分）
- 并发：任务调度器使得CPU在同一段时间执行不同的任务,微观串行，宏观并行
- 并行：在同一时刻cpu做多件事情的能力
-
异步同步（从方法的角度划分）
- 方法的执行需要等待别的结果返回，就是同步
- 不需要等待别的方法结果返回，就是异步
-
三种方法创建线程
# 方法一 Thread t = new Thread(){ public void run(){ xxxxx; } }; t.setName("t1") t.start(); # 方法二 Runnable r = new Runnable(){ public void run(){ xxxxxx; } } Thread t = new Thread(r,"t2") t.start(); # 方法三：简化lambda Runnable t = ()->{xxxxx;}; Thread t = new Thread(r,"t2") t.start(); # FutureTask是带有返回值的Runnable# windows tasklist 查看所有进程 jps 显示所有的java进程 taskkill 杀死某个进程 # linux ps -fe 查看所有的命令进程 ps -fe | grep java 筛选带有Java的 jps 列出java进程 kill 4202 杀死进程 top 查看进程信息 top -H -p 4262 查看该进程的线程信息 jstack 4262 查看某个时刻的线程信息 -
字节码放到方法区（二进制格式）
-
jvm启动main线程，并分配main栈帧
- 线程上下文切换：cpu不再执行当前线程，转而执行另一个线程代码
- 线程的cpu时间片用完
- 垃圾回收
- 有更高优先级的线程
- 线程自己调用sleep，yield，wait，join，park，synchronized，lock方法
- context switch的时候，需要操作系统保存当前线程的状态，包括：
- 程序计数器、虚拟机栈中每个栈帧的信息（局部变量、操作数栈、返回地址）
-
知识点
-
start 和 run 的区别（start是由别的线程调用从而启动A线程的，调用后不会影响该线程的本身进度，run是由线程A分配到cpu后才执行的）
-
sleep和yield
- sleep就是放弃了cpu的使用，进入TIMED_WAITING阻塞状态
- yield：让线程从RUNNABLE变为RUNNABLE 就绪状态
- 在哪个线程下写 thread.sleep就是休眠哪个线程
- 状态: NEW — RUNNABLE(可以被cpu调用的) — TIMED_WAITING (休眠)
- 区别：cpu仍然会考虑yield，但是不会考虑sleep
-
线程优先级setPriority：只是一个提示，调度器可以忽略这个信号
-
join：等待线程运行结束，哪个线程调用就等待哪个线程
-
join（时间）：等待 min（时间，线程执行时间）
-
interrupt
-
打断阻塞状态：sleep wait join 这些打断后isInterrupted重新置为false（打断后不能立即查看，需要等打断进入到异常块才能看到重置为false）
public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { log.debug("sleep..."); try { Thread.sleep(5000); // wait, join } catch (InterruptedException e) { e.printStackTrace(); } },"t1"); t1.start(); Thread.sleep(1000); log.debug("interrupt"); t1.interrupt(); // 这里如果没有等，可能还没有等t1重置为false就打印出true Thread.sleep(1000); log.debug("打断标记:{}", t1.isInterrupted()); } -
打断正常状态：isInterrupted置为true，但是线程不会结束，需要自己再去判断是否真的要停止，获得currentThread(). isInterrupted 判断是否为true
@Slf4j(topic = "c.Test12") public class Test12 { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { while(true) { boolean interrupted = Thread.currentThread().isInterrupted(); // 没有判断的话就一直不会停止 if(interrupted) { log.debug("被打断了, 退出循环"); break; } } }, "t1"); t1.start(); Thread.sleep(1000); log.debug("interrupt"); t1.interrupt(); } }
-
-
两阶段终止模式（A线程如何优雅的停止B线程）
``` @Slf4j(topic = "c.TwoPhaseTermination") class TwoPhaseTermination { // 监控线程 private Thread monitorThread; // 停止标记 private volatile boolean stop = false; // 判断是否执行过 start 方法 private boolean starting = false; // 启动监控线程 public void start() { synchronized (this) { if (starting) { // false return; } starting = true; } monitorThread = new Thread(() -> { while (true) { Thread current = Thread.currentThread(); // 是否被打断 if (stop) { log.debug("料理后事"); break; } try { Thread.sleep(1000); log.debug("执行监控记录"); } catch (InterruptedException e) { } } }, "monitor"); monitorThread.start(); } // 停止监控线程 public void stop() { stop = true; monitorThread.interrupt(); } } ``` -
park：代码会停止在执行park()的这一行，遇到interrupt后才会继续（标记为true），且以后再遇到park也不会停止，除非再次重置为false
-
不推荐用的：
- stop：强制让线程停止，即线程的资源可能还未被释放
- suspend：挂起线程
- resume 恢复线程运行
-
主线程和守护线程：只要其他非守护线程结束，那么即使守护线程没有运行结束，也会停止运行（垃圾回收线程）
t1.setDaemon(true); //设置守护线程 -
线程的状态（操作系统层面）
- 初始状态：仅语言层面创建线程对象，与操作系统未关联
- 可运行状态：cpu可以调度
- 运行状态：获取了cpu时间片
- 阻塞：
- 终止状态
-
线程六种状态（java层面）
- 初始状态：new但是尚未start
- RUNNABLE:start之后线程的运行状态，可运行状态，阻塞状态
- BLOCKED：拿不到锁
- WAITING：join
- TIMED_WAITING:sleep
- TERMINATED：终止
package cn.itcast.n3; import lombok.extern.slf4j.Slf4j; import java.io.IOException; @Slf4j(topic = "c.TestState") public class TestState { public static void main(String[] args) throws IOException { Thread t1 = new Thread("t1") { @Override public void run() { log.debug("running..."); } }; Thread t2 = new Thread("t2") { @Override public void run() { while(true) { // runnable } } }; t2.start(); Thread t3 = new Thread("t3") { @Override public void run() { log.debug("running..."); } }; t3.start(); Thread t4 = new Thread("t4") { @Override public void run() { synchronized (TestState.class) { try { Thread.sleep(1000000); // timed_waiting } catch (InterruptedException e) { e.printStackTrace(); } } } }; t4.start(); Thread t5 = new Thread("t5") { @Override public void run() { try { t2.join(); // waiting } catch (InterruptedException e) { e.printStackTrace(); } } }; t5.start(); Thread t6 = new Thread("t6") { @Override public void run() { synchronized (TestState.class) { // blocked try { Thread.sleep(1000000); } catch (InterruptedException e) { e.printStackTrace(); } } } }; t6.start(); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } log.debug("t1 state {}", t1.getState()); log.debug("t2 state {}", t2.getState()); log.debug("t3 state {}", t3.getState()); log.debug("t4 state {}", t4.getState()); log.debug("t5 state {}", t5.getState()); log.debug("t6 state {}", t6.getState()); System.in.read(); } }
-
