首页 学习笔记

# 进程与线程

# 进程

  • 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载到内存。在指令运行过程中还需要用到磁盘，网络设备。进程就是用来加载指令、管理内存、管理 io 的
  • 当一个程序被运行，从磁盘加载这个程序的代码至内存，这是就开启了一个进程。
  • 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程

# 线程

  • 一个进程之内可以分为一到多个线程。
  • 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 cpu 执行。
  • Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。在 windows 中进程是不活动的，只是作为线程的容器。

二者对比

  • 进程基本上相互独立，而线程存在于进程内，是进程的一个子集。

  • 进程拥有共享的资源，如内存空间

  • 进程间通信较为复杂

    • 同一台计算机 的进程通信称为 IPC（Inter-process Communication）
    • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP

  • 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量

  • 线程更加轻量，线程上下文切换成本一般要比进程上下文切换低

# 应用

# 异步调用

  • 需要等待结果返回才能继续运行就是同步
  • 不需要等待结果返回，就能继续运行就是异步

注意：同步在多线程还有一层意思，即让多个线程步调一致

多线程可以让方法的执行变为异步，例如读取磁盘文件，可以单独创建一个线程进行，不至于等待其完成再顺序执行

tomcat 的异步也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程

# 线程

# 创建

方法 1：直接使用 Thread

// 创建线程对象
Thread t = new Thread() {
    public void run() {
        // 要执行的任务
    }
}
// 	启动线程
t.start();

例如：

// 构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {
    @Override
    //run 方法内实现了要执行的任务
    public void run(){
        log.debug("hello");
    }
};
t1.strat();

方法 2：使用 Runnable 配合 Thread

class B implements Runable {
    @Override
    public void run() {
        int i = 80;
        while(i>0){
            System.out.println("miaomiao--"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            i--;
        }
    }
}
public static void main(String[] args) {
        new Thread(new B()).start();
    }

方法 3：FutureTask 配合 Thread

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

// 创建任务对象
FutureTask<Integer> task = new FutureTask<>(()->{
    log.debug("hello");
    return 100;
});
// 参数 1 任务对象，参数 2 线程名字
new Thread(task, "t").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task.get();
log.debug("结果是:{}", result);
# Thread 与 Runnable 的关系
  • 方法 1 是把线程和任务合并在一起，方法 2 是把线程和任务分开
  • 用 Runnable 更容易与线程池高级 API 配合
  • 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活
# 查看进程线程的方法
windows
  • tasklist
  • taskkill
Linux
- ps -fe
- ps -fT -p <PID>
kill
top
top -H -p <PID>
JAVA
  • jps 命令查看所有 java 进程
  • jstack <PID> 查看某个 Java 进程 (PID) 的所有状态
  • Jconsole 查看 java 进程运行情况
# Jconsole 连接远程监控
需要以如下方式运行你的 java 类
java -Djava.rmi.server.hostname='ip地址' -Dcom.sun.management.jmxremote.ssl=是否安全连接 -Dcom.sun.management.jmxremote.authenticate=是否认证 java类
  • 修改 /etc/hosts 文件将 127.0.0.1 映射至主机名
如果要认证访问，还需要做如下步骤
  • 复制 jmxremote.password 文件
  • 修改 jmxremote.password 和 jmxremote.access 文件的权限为 600 即文件所有者可以读写
# 原理与线程运行
# 栈与栈帧
JVM 由堆、栈、方法区所组成，栈内存给线程使用，每个线程启动后，虚拟机就会为其分配一块栈内存。
  • 每个栈由多个栈帧组成，对应着每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法
# 线程上下文切换（Thread Context Switch）
因为以下一些原因导致 cpu 不再执行当前的进程，转而执行另一个线程的代码
  • 线程的 cpu 时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要执行
  • 线程自己调用 sleep、yield、wait、join、park、synchronized、lock 等方法 chengxu
当 Context Switch 发生时，需要操作系统来保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器，它的作用就是记住下一条 jvm 指令的执行地址，是线程私有的
# 常用方法
image-20221004094936815
image-20221004095700430
# sleep
  1. 调用 sleep 会让当前线程从 running 进入 Timed Waiting 状态
  2. 其他线程可以使用 interrupt 方法打断正在睡眠的线程，这时线程会抛出 InterruptedException 异常
  3. 睡眠结束后的线程未必会立刻得到执行
  4. 建议使用 TimeUnit 的 sleep 代替 Tread 的 sleep 来获得更好的可读性
# yield
  1. 调用 yield 方法会让当前线程从 running 转到 runnable 状态，然后调度执行其他同优先级的线程。如果当前没有同优先级的线程，不能保证让当前线程暂停的效果。
  2. 具体操作依赖于操作系统任务调度器
# 线程优先级
  • 线程优先级会提示调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
  • 如果 cpu 很忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用。
private static void printInfo() {
    log.dubug("priority is {}", Thread。currentThread().getProiority());
}
# 案例：防止 cpu 占用 100%
# sleep 实现
在没有利用 cpu 计算时，while (true) 空转会浪费 cpu，这时可以使用 yield 或 sleep 来让 cpu 的使用权给其他程序
while(true){
    try{
        Thread.sleep(50);
    }catch(InterrupterdException e){
        e.printStackTrace();
    }
}
  • 可以用 wait 或条件变量达到类似效果
  • 不同的是，后者需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
  • sleep 适用于无需同步的场景
# join
static int r = 0;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
                r = 1;
            } catch (InterruptedException e) {
                log.debug("wake up");
                e.printStackTrace();
            }
        }, "t1");
        t1.start();
        log.debug("{}", r);
    }
打印结果为 r=0
这是因为主线程在 r 复制之前就执行了日志打印，等待 t1 执行完需要调用 t1.join() （启动 t1 之后）
# 应用同步
从调用方的角度讲：
  • 需要等待结果返回，才能继续执行的是同步
  • 不需要等待结果返回，就能继续执行的是异步
sleep、join、wait 被打断后会清除打断标记，也就是打断标记不会为真值
# 模式之两阶段终止模式 *
在一个线程 T1 中如何优雅终止线程 T2
错误思路：
  • 使用 stop（）方法停止线程
    • stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么它被杀死后就再也没有机会释放锁，其他线程将永远无法获取锁。
  • 使用 System.exit (ini) 方法停止线程
    • 目的仅仅是停止一个线程，但会让整个程序停止运行。
graph TD
    w("while(true)") --> a
    a("有没有被打断")-- 是 --> b("料理后事")
    b --> c(("结束循环"))
    a --否--> d("睡眠2s")
    d --有异常-->i(设置打断标记)
    d --无异常-->e(执行监控记录)
    i --> w
    e --> w
@Slf4j(topic = "TwoPhaseTermination")
class TwoPhaseTermination {
    private Thread monitor;
    // 启动监控线程
    public void start() {
        monitor = new Thread(() -> {
            while(true){
                Thread current = Thread.currentThread();
                if(current.isInterrupted()){
                    log.debug("得，料理后事");
                    break;
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                    log.debug("执行监控记录");
                }catch (InterruptedException e){
                    e.printStackTrace();
                    log.debug("睡眠时打断");
                    // 设置打断标记
//                    current.interrupt();
                }
            }
        });
        monitor.start();
    }
    public void stop(){
        monitor.interrupt();
    }
}
// 执行
public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        TimeUnit.SECONDS.sleep(4);
        tpt.stop();
    }
# 关于 park () 和 interrupted () 方法
park () 方法会使的未被打断的线程（或打断标记为 false）阻塞，当线程再次被打断时（打断标记为 true）继续运行。
interrupted () 方法会打断线程并且清除打断标记（置 false）
# 不推荐方法：
理由：方法过时，容易破坏同步代码块，造成线程死锁
  • stop ( ) 停止线程
  • suspend ( ) 挂起线程
  • resume ( ) 恢复线程运行
# 主线程与守护线程
默认情况下，java 进程需要等待所有线程都结束才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束，即使守护线程的代码没执行完，也会强制结束。
public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while(true){
                if(Thread.currentThread().isInterrupted()){
                    break;
                }
            }
            log.debug("结束");
        }, "t1");
        t1.setDaemon(true);
        t1.start();
        Thread.sleep(1000);
        log.debug("结束1");
    }
  • 垃圾回收线程就是一个守护线程
  • tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 Shutdown 命令后，不会等待它们处理完请求
# 线程的六个状态
在 Thead 的内部枚举类 State 定义了线程的六个状态：
<span style="color:red">NEW</span>（尚未启动的线程处于此状态，创建为调用 start() 方法）
<span style="color:red">RUNNABLE</span>（在 Java 虚拟机执行的线程处于此状态 | 操作系统层面的可运行、阻塞、运行都是此状态）
<span style="color:red">BLOCKED</span>（被阻塞等待监视器锁定的线程处于此状态）
<span style="color:red">WAITING</span>（正在等待另一个线程执行特定动作的线程处于此状态）
<span style="color:red">TIMED_WAITING</span>（正在等待另一个线程执行动作达到指定等待时间的线程处于此状态）
<span style="color:red">TERMINATED</span>（已退出的线程处于此状态）
img
@Slf4j(topic = "ThreadState")
public class ThreadState {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            log.debug("running");
        }, "t1");
        Thread t2 = new Thread(() -> {
            while (true) {
            }
        }, "t2");
        t2.start();
        Thread t3 = new Thread(() -> {
            log.debug("running");
        }, "t3");
        t3.start();
        Thread t4 = new Thread(() -> {
            synchronized (ThreadState.class) {
                try {
                    TimeUnit.SECONDS.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t4");
        t4.start();
        Thread t5 = new Thread(() -> {
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t5");
        t5.start();
        Thread t6 = new Thread(() -> {
            synchronized (ThreadState.class) {
                try {
                    TimeUnit.SECONDS.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t6");
        t6.start();
        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());
    }
}
结果：
21:25:24 [main] ThreadState - t1 state:NEW
21:25:24 [t3] ThreadState - running
21:25:24 [main] ThreadState - t2 state:RUNNABLE
21:25:24 [main] ThreadState - t3 state:TERMINATED
21:25:24 [main] ThreadState - t4 state:TIMED_WAITING
21:25:24 [main] ThreadState - t5 state:WAITING
21:25:24 [main] ThreadState - t6 state:BLOCKED
# 小结
  • 线程创建
    • 线程重要 api， start ， run ， sleep ， join ， interrupt 等
    • 线程六个状态
    • 应用方面
      • 异步调用
      • 提高效率
      • 同步等待
      • 统筹规划
    • 原理方面
      • 线程运行流程：栈、栈帧、上下文切换、程序计数器
      • Thread 两种创建方式的源码
    • 模式方面
      • 两阶段终止模式
 
 更新于   阅读次数  次 本文阅读量:
请我喝[茶]~(￣▽￣)~*
Windlinxy 微信支付
微信支付
Windlinxy 支付宝
支付宝