首页 学习笔记

# 进程与线程

# 进程

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

# 线程

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

二者对比

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

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

  • 进程间通信较为复杂

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

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

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

# 应用

# 异步调用

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

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

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

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

# 线程

# 创建

方法 1：直接使用 Thread

1
2
3
4
5
6
7
8
// 创建线程对象
Thread t = new Thread() {
    public void run() {
        // 要执行的任务
    }
}
// 	启动线程
t.start();

例如：

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

方法 2：使用 Runnable 配合 Thread

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 类型的参数，用来处理有返回结果的情况

1
2
3
4
5
6
7
8
9
10
11
12
// 创建任务对象
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

1
2
3
4
5
- ps -fe
- ps -fT -p <PID>
kill
top
top -H -p <PID>

JAVA

  • jps 命令查看所有 java 进程
  • jstack <PID> 查看某个 Java 进程 (PID) 的所有状态
  • Jconsole 查看 java 进程运行情况

# Jconsole 连接远程监控

需要以如下方式运行你的 java 类

1
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 闲时，优先级几乎没作用。

1
2
3
private static void printInfo() {
    log.dubug("priority is {}", Thread。currentThread().getProiority());
}

# 案例：防止 cpu 占用 100%

# sleep 实现

在没有利用 cpu 计算时，while (true) 空转会浪费 cpu，这时可以使用 yield 或 sleep 来让 cpu 的使用权给其他程序

1
2
3
4
5
6
7
while(true){
    try{
        Thread.sleep(50);
    }catch(InterrupterdException e){
        e.printStackTrace();
    }
}

  • 可以用 wait 或条件变量达到类似效果
  • 不同的是，后者需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
  • sleep 适用于无需同步的场景

# join

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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) 方法停止线程
    • 目的仅仅是停止一个线程，但会让整个程序停止运行。

1
2
3
4
5
6
7
8
9
graph TD
    w("while(true)") --> a
    a("有没有被打断")-- 是 --> b("料理后事")
    b --> c(("结束循环"))
    a --否--> d("睡眠2s")
    d --有异常-->i(设置打断标记)
    d --无异常-->e(执行监控记录)
    i --> w
    e --> w

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@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 进程需要等待所有线程都结束才会结束。有一种特殊的线程叫做守护线程，只要其它非守护线程运行结束，即使守护线程的代码没执行完，也会强制结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
@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());
    }
}

结果：

1
2
3
4
5
6
7
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 支付宝

支付宝