java并发编程学习一——Thread

文章目录

一、常用方法
二、主要方法详解
三、线程状态

一、常用方法

function_name	static	功能说明	注意
start()	否	启动一个线程，在新线程中执行run方法中的代码	start方法只是让线程就绪，并不是马上执行（CPU时间片还没分配给它），start方法只能调用一次，再次调用会报IllegalThreadStateException
run()	否	新线程启动之后会调用的方法	如果在Thread的构造方法传入了Runnable参数，则线程启动执行Runnable的run方法，否则不执行任何操作。可以继承Thread来重写run方法，覆盖默认行为
join()	否	等待线程运行结束
join(long n)	否	等待线程运行结束，最多等待n毫秒
getId()	否	获取线程的长整型id	id唯一
getName()	否	获取线程名
setName(String)	否	设置线程名
getPriority()	否	获取线程优先级
setPriority(int)	否	设置线程优先级	java规定线程优先级是1-10的整数，数值越大优先级越高，被cpu调度的概率越大
getState()	否	获取线程状态	线程状态有6中，定义在枚举中：NEW、RUNNABLE、BLOCKED、WAIT、TIMED_WAIT、TERMINATED
isAlive()	否	线程是否存活（尚未运行完）
interruput()	否	给线程添加中断标记	RUNNABLE、BLOCKED状态的线程只是添加中断标记，不会改变状态。WAITING、TIMED_WAITING状态的线程会抛出异常InterruptedException，并将线程状态改为RUNNABLE，同时清除中断标记
isInterrupted()	否	判断当前线程的中断标记，不会清除标记
interrupted()	是	判断当前线程的中断标记，会清除标记
currentThread()	是	获取当前正在运行的线程对象
sleep(long n)	是	让当前正在运行的线程休眠n毫秒，让出cpu时间片，但不会释放锁
yield()	是	让出cpu时间片，进入就绪状态，重新等待调度，会释放锁	主要用于测试和调试

二、主要方法详解

2.1 start与run

start可以启动一个线程，run里面操作可以看做线程的任务。直接调用run方法，会在主线程执行run里面的操作，这块比较简单就不写demo了。

2.2 sleep与yield

sleep：

RUNNABLE(running)状态进入TIMED_WAITING
其他线程可以使用interrupt方法打断正在睡眠的线程，抛出InterruptedException
打断之后睡眠结束，但未必立即执行
建议使用TimeUnit的sleep代替Thread的sleep

演示代码：

public class SleepAndYield {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
//                Thread.sleep(2000);
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");
        System.out.println(t1.getState());
        t1.start();
        System.out.println(t1.getState());
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(t1.getState());

        t1.interrupt();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t1.getState());

    }
}
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

yield:

RUNNABLE(running)状态进入RUNNABLE(runnable)
让出cpu时间片执行其他同优先级的线程，如果没有同优先级的线程，那么不保证当前线程的暂停效果
具体线程的执行依赖操作系统的任务调度器

演示代码：

public class SleepAndYield1 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            int count =0;
            while (true){
                System.out.println("t1----->"+count++);
            }
        },"t1");

        Thread t2 = new Thread(() -> {
            int count =0;
            while (true){
                Thread.yield();
                System.out.println("            t2----->"+count++);
            }
        },"t2");

        t1.start();
        t2.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.2.1 Thread.yield()和Thread.sleep(0)区别

无锁下相同：

Thread.yield()和Thread.sleep(0)都会让线程放弃剩余的cpu时间片，重新变为RUNNABLE状态，并放到同优先级线程队列的末尾等待cpu资源

有锁下不同：

Thread.yield()会让当前线程让出持有的锁，和其他线程去争抢锁，状态变为BLOCKED
Thread.sleep(0)并不会让出锁，依然是锁的持有者，状态还是RUNNABLE

2.3 join

join方法等待所属线程对象的线程执行结束，会阻塞调用它的线程
演示代码：

public class Join {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> sleep(1), "t1");

        Thread t2 = new Thread(() -> sleep(2), "t2");

        t1.start();
        t2.start();
        long start =System.currentTimeMillis();
        t1.join();
        t2.join();
        long end =System.currentTimeMillis();
        System.out.println(end-start);
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

限时等待

public class JoinN {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> sleep(2), "t1");
        t1.start();
        long start =System.currentTimeMillis();
        t1.join(1000);
        long end =System.currentTimeMillis();
        System.out.println(end-start);
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.4 interrupt

RUNNABLE、BLOCKED状态的线程只是添加中断标记，不会改变状态。WAITING、TIMED_WAITING状态的线程会抛出异常InterruptedException，并将线程状态改为RUNNABLE，同时清除中断标记。
打断WAIT、TIMED_WAIT线程：

public class Interrupt1 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> sleep(2), "t1");
        t1.start();
        sleep(1);
        t1.interrupt();
        System.out.println("打断标记：" + t1.isInterrupted());
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

打断RUNNABLE线程：
不能让t1线程停止运行

public class Interrupt2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true){

            }
        }, "t1");
        t1.start();
        sleep(1);
        t1.interrupt();
        System.out.println("打断标记：" + t1.isInterrupted());
    }
1
2
3
4
5
6
7
8
9
10
11
12

加判断让t1线程停止运行

public class Interrupt2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if(Thread.interrupted()){
                    System.out.println("被打断了...");
                    break;
                }

            }
        }, "t1");
        t1.start();
        sleep(1);
        t1.interrupt();
        //输出false，因为interrupted()会清除打断标记
        System.out.println("打断标记：" + t1.isInterrupted());
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
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

2.4.1 两阶段interrupt停止线程

public class Interrupt3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("执行监控");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //二阶段打断
                    Thread.currentThread().interrupt();
                }

                if(Thread.interrupted()){
                    System.out.println("被打断了...");
                    break;
                }

            }
        }, "t1");
        t1.start();
        Thread.sleep(3500);
        //一阶段打断，t1线程正好在睡眠中，标记的打断会被清除，因此需要在catch块添加二阶段打断
        t1.interrupt();
        System.out.println("打断标记：" + t1.isInterrupted());
    }
}
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

2.4.2 interrupt打断park线程

public class Interrupt4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("before park");
            LockSupport.park();
            System.out.println("after interrupt");
            //被标记打断的线程，再次park，无法暂停
            LockSupport.park();
            System.out.println("can't park");
        }, "t1");
        t1.start();
        Thread.sleep(1000);
        t1.interrupt();
        System.out.println("结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.5 setDaemon

setDaemon将设置线程为守护线程，顾名思义守护其他线程的线程，当没有线程需要守护，自己就强制结束了。

public class SetDaemon {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                System.out.println("Daemon main thread");
            }

        }, "t1");
        t1.setDaemon(true);
        t1.start();
        sleep(1);
        System.out.println("main thread over!");

    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

三、线程状态

3.1 OS层面

OS层面有以下五种状态：初始状态–>可运行–>运行中–>阻塞–>终止
在这里插入图片描述

初始状态：在编程语言创建了线程，还未提交到操作系统进行关联
可运行状态：已提交到操作系统的任务调度器，等待被调度运行
运行状态：获得了CPU时间片正在运行，与可运行状态来回切换即CPU上下文切换
阻塞状态：执行阻塞任务中，例如调用阻塞IO，这时线程不占用CPU，导致上下文切换进入阻塞状态。阻塞任务完成之后会被操作系统唤醒，重新进入可运行状态等待调度。阻塞状态的线程只要不被唤醒，调度器就不会考虑调度它
终止状态：线程执行完毕，生命周期结束，不再转换其它状态

3.2 JVM层面

Java语言中，在Thread类定义了一个状态枚举，表示线程的状态，有以下六种：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。看下六种状态对应的代码

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {
            }
        }, "t2");
        t2.start();

        Thread t3 = new Thread(() -> {
            synchronized (ThreadState.class) {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t3");
        t3.start();

        Thread t4 = new Thread(() -> sleep(1000), "t4");
        t4.start();

        Thread t5 = new Thread(() -> {
            synchronized (ThreadState.class) {
            }
        }, "t5");
        t5.start();

        Thread t6 = new Thread(() -> {
        }, "t6");
        t6.start();
        Thread.sleep(2);
        System.out.println("t1：" + t1.getState());
        System.out.println("t2：" + t2.getState());
        System.out.println("t3：" + t3.getState());
        System.out.println("t4：" + t4.getState());
        System.out.println("t5：" + t5.getState());
        System.out.println("t6：" + t6.getState());
    }

    private static void sleep(int i) {
        try {
            TimeUnit.SECONDS.sleep(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
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

再看下状态转换图简易版
在这里插入图片描述

初始状态（NEW），线程对象被创建出来就进入了初始状态
可运行状态（RUNNABLE），包含了操作系统中的运行、可运行、和一部分阻塞。自身又可细分为就绪和运行中
- 就绪，线程进入了调度器队列，尚未被调度
- 运行中，被调度器调度，从而获得CPU时间片正在运行
阻塞（BLOCKED），线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态
等待（WAITING），进入等待的线程，需要被显示唤醒才能再次进入可运行状态，否则将一直等待下去
超时等待（TIMED_WAITING）与等待状态的区别是，有时间期限，到时自动唤醒
终止（TERMINATED），run方法里的任务执行完就进入终止状态，线程对象也许还存活，但无法再次调用start，否则将抛出异常

3.3 OS与JVM线程状态对比

在这里插入图片描述
如图所示：开始和终止状态一样的，java中将就绪和运行合并为可运行，将阻塞细分为阻塞、等待和超时等待。值得注意的是，操作系统中一部分阻塞，在java中认为是可运行状态，例如IO阻塞。

相关阅读:
微信小程序返回上一页刷新组件数据
 JMeter HTTP请求的详细指南，还不知道的快来看
 历时一年，论文终于被国际顶会接收了
 ES6 入门教程 23 Class 的继承 23.1 简介
 Node.js躬行记（20）——KOA源码分析（下）
企业电子招标采购系统源码之从供应商管理到采购招投标、采购合同、采购执行的全过程数字化管理
 springboot+vue“智慧食堂”设计与实现springboot002
protobuf 基本使用
 【LeetCode力扣】297. 二叉树的序列化与反序列化
 Qt教程 — 3.1 深入了解Qt 控件：Buttons按钮
原文地址：https://blog.csdn.net/yx444535180/article/details/126246434