学习目标:

除了标记了解的, 其余的都掌握

引例:单线程不能满足”同时”的需求#

假如我要实现如下功能程序不停地在屏幕上输出一句问候的语句(比如“你好”) “同时”，当我通过键盘输入固定输入的时候，程序停止向屏幕输出问候的语句(比如说输入gun)

单线程

无法做到”同时”发生

1
package _19thread01.com.cskaoyan._01introduction;
2

3
import java.util.Scanner;
4
import java.util.concurrent.TimeUnit;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/19 9:11
10
 **/
11
/*
12
程序不停地在屏幕上输出一句问候的语句(比如“你好”)  ----> sayHello()
13
“同时”，当我通过键盘输入固定输入的时候，          --->waitToStop()
14
程序停止向屏幕输出问候的语句(比如说输入gun)
15
 */
16
public class Demo {
17
    public static boolean flag = true;
18
    public static void main(String[] args) {
19
        System.out.println("main before");
20
        System.out.println("hello before");
21

22
        sayHello();
23
        System.out.println("hello after");
24

25

26
        System.out.println("wait before");
27
        waitToStop();
28
        System.out.println("wait after");
29

30

31
        System.out.println("main after");
32

33
    }
34

35
    private static void waitToStop() {
36
        Scanner scanner = new Scanner(System.in);
37
        // 多次输入
38
        while (flag) {
39
            String s = scanner.nextLine();
40
            if ("gun".equals(s)) {
41
                flag = false;
42
                break;
43
            }
44
        }
45
    }
46

47
    private static void sayHello() {
48
        while (flag) {
49
            System.out.println("你好");
50
            try {
51
                // 让程序暂停执行3秒
52
                TimeUnit.SECONDS.sleep(3);
53
            } catch (InterruptedException e) {
54
                e.printStackTrace();
55
            }
56
        }
57
    }
58
}

多线程

可以做到同时发生

1
package _19thread01.com.cskaoyan._01introduction;
2

3
import java.util.Scanner;
4
import java.util.concurrent.TimeUnit;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/19 9:11
10
 **/
11
/*
12
程序不停地在屏幕上输出一句问候的语句(比如“你好”)  ----> sayHello()
13
“同时”，当我通过键盘输入固定输入的时候，          --->waitToStop()
14
程序停止向屏幕输出问候的语句(比如说输入gun)
15

16
多线程改进
17
 */
18
public class Demo2 {
19
    public static boolean flag = true;
20
    public static void main(String[] args) {
21
        System.out.println("main before");
22
        System.out.println("hello before");
23

24
        sayHello();
25
        System.out.println("hello after");
26

27

28
        System.out.println("wait before");
29
        waitToStop();
30
        System.out.println("wait after");
31

32

33
        System.out.println("main after");
34

35
    }
36

37
    private static void waitToStop() {
38
        new Thread(new Runnable() {
39
            @Override
40
            public void run() {
41
                Scanner scanner = new Scanner(System.in);
42
                // 多次输入
43
                while (flag) {
44
                    String s = scanner.nextLine();
45
                    if ("gun".equals(s)) {
46
                        flag = false;
47
                        break;
48
                    }
49
                }
50
            }
51
        }).start();
52

53
    }
54

55
    private static void sayHello() {
56
        new Thread(new Runnable() {
57
            @Override
58
            public void run() {
59
                while (flag) {
60
                    System.out.println("你好");
61
                    try {
62
                        // 让程序暂停执行3秒
63
                        TimeUnit.SECONDS.sleep(3);
64
                    } catch (InterruptedException e) {
65
                        e.printStackTrace();
66
                    }
67
                }
68
            }
69
        }).start();
70

71
    }
72
}

操作系统基本概念#

进程(process)与线程(thread)#

进程

计算机程序在某个数据集合上的运行活动.进程是操作系统进行资源调度与分配的基本单位
正在运行的程序或者软件

线程

进程中有多个子任务,每个子任务就是一个线程. 从执行路径的角度看, 一条执行路径就是一个线程
线程是CPU进行资源调度与分配的基本单位

进程与线程的关系

线程依赖于进程而存在
一个进程中可以有多个线程(最少1个)
线程共享进程资源
举例: 迅雷, Word拼写

串行(serial),并行(parallel)与并发(concurrency)#

串行

一个任务接一个任务按顺序执行

并行

在同一个时间点(时刻)上, 多个任务同时运行

并发

在同一时间段内,多个任务同时运行

同步(synchronization)与异步(asynchronization)#

有2个任务(业务) A B

同步:

A任务执行的时候B不能执行,按顺序执行
你走我不走

异步:

A任务执行的时候,B任务可以执行
你走你的,我走我的,互相不干扰
多线程是天生异步的

举例: 去书店买java书, 给老板打了个电话, 问有没有java书

同步: 老板说找一下,然后告诉我, 电话没有挂断, 我在电话另一端等待.

异步:老板说找一下,然后告诉我, 电话挂断. 等老板找到后, 再通知我, 我在电话另一端不用等待

单道批处理: 内存中只能运行一个进程

多道批处理: 内存中可以运行多个进程, “同时”发生 (进程的上下文切换)

现代操作系统: 引入了线程

java程序运行原理#

java命令+主类类名运行原理#

java命令会启动jvm进程, jvm进程会创建一个线程(main线程)
执行main线程里面的main方法

jvm是单线程还是多线程的#

结论: jvm是多线程的

除了main线程外,还有其他线程,起码还有一个垃圾回收线程

多线程的实现方式一:继承Thread类#

线程是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

文档示例#

步骤#

定义一个类继承Thread类
重写run方法
创建子类对象
通过start方法启动线程

Demo

1
package _19thread01.com.cskaoyan._02implone;
2

3
import java.util.concurrent.TimeUnit;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/19 11:11
9
 **/
10
/*
11
多线程的实现方式一:
12
1. 定义一个类继承Thread类
13
2. 重写run方法
14
3. 创建子类对象
15
4. 通过start方法启动线程
16
 */
17
public class Demo {
18
    public static void main(String[] args) {
19
        System.out.println("main start");
20
        //3. 创建子类对象
21
        MyThread t = new MyThread();
22
        // 4. 通过start方法启动线程
23
        t.start();
24
        try {
25
            TimeUnit.MILLISECONDS.sleep(1);
26
        } catch (InterruptedException e) {
27
            e.printStackTrace();
28
        }
29
        System.out.println("main end");
30

31
    }
32
}
33

34

35
//1. 定义一个类继承Thread类
36
class MyThread extends Thread{
37
    //2. 重写run方法
38

39
    @Override
40
    public void run() {
41
        System.out.println("子线程执行了!");
42
    }
43
}

1
没加等待的结果:
2
main start
3
main end
4
子线程执行了!
5

6
加上等待的结果:
7
main start
8
子线程执行了!
9
main end

注意事项#

多线程的执行特点是什么?

执行特点是随机的

1
package _19thread01.com.cskaoyan._02implone;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 11:19
7
 **/
8
/*
9
多线程的执行特点
10
 */
11
public class Demo2 {
12
    public static void main(String[] args) {
13
        // 创建并启动2个线程
14
        MyThread2 t1 = new MyThread2();
15
        MyThread2 t2 = new MyThread2();
16

17
        // start()
18
        t1.start();
19
        t2.start();
20
    }
21
}
22

23
class MyThread2 extends Thread{
24
    // run
25

26
    @Override
27
    public void run() {
28
        for (int i = 0; i < 10; i++) {
29
            // getName() 获取线程名称
30
            System.out.println(getName()+"----"+i);
31
        }
32
    }
33
}

1
执行结果:
2
Thread-1----0
3
Thread-1----1
4
Thread-0----0
5
Thread-0----1
6
Thread-0----2
7
Thread-0----3
8
Thread-0----4
9
Thread-0----5
10
Thread-1----2
11
Thread-0----6
12
Thread-0----7
13
Thread-0----8
14
Thread-0----9
15
Thread-1----3
16
Thread-1----4
17
Thread-1----5
18
Thread-1----6
19
Thread-1----7
20
Thread-1----8
21
Thread-1----9

start方法跟run方法有什么区别?

start方法才是开辟新的执行路径, run方法只是普通方法调用, 并没有开辟新的执行路径, 还是一条执行路径, 仍然是单线程的.

1
package _19thread01.com.cskaoyan._02implone;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 11:19
7
 **/
8
/*
9
start() vs run()
10
 */
11
public class Demo3 {
12
    public static void main(String[] args) {
13
        System.out.println("main start");
14
        // 创建并启动2个线程
15
        MyThread3 t1 = new MyThread3();
16

17
        // start()
18
        // t1.start();
19
        // run()方法只是一个普通方法调用
20
        t1.run();
21
        System.out.println("main end");
22

23
    }
24
}
25

26
class MyThread3 extends Thread{
27
    // run
28

29
    @Override
30
    public void run() {
31
        for (int i = 0; i < 10; i++) {
32
            System.out.println(i);
33
        }
34
    }
35
}

1
调用start()方法的结果:
2
main start
3
main end
4
0
5
1
6
2
7
3
8
4
9
5
10
6
11
7
12
8
13
9
14
调用run()方法的结果:
15
main start
16
0
17
1
18
2
19
3
20
4
21
5
22
6
23
7
24
8
25
9
26
main end

同一个线程能否启动多次?

不能启动多次, java.lang.IllegalThreadStateException

1
package _19thread01.com.cskaoyan._02implone;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 11:19
7
 **/
8
/*
9
同一个线程对象能否启动多次?
10
 */
11
public class Demo4 {
12
    public static void main(String[] args) {
13
        System.out.println("main start");
14
        // 创建并启动2个线程
15
        MyThread4 t1 = new MyThread4();
16

17
        // start()
18
        t1.start();
19
        t1.start();
20

21
        System.out.println("main end");
22

23
    }
24
}
25

26
class MyThread4 extends Thread{
27
    // run
28

29
    @Override
30
    public void run() {
31
        for (int i = 0; i < 10; i++) {
32
            System.out.println(i);
33
        }
34
    }
35
}

谁才代表一个线程?

Thread及其子类对象才代表线程, 就是t1,t2

设置获取线程名称#

获取名字

String	getName() 返回该线程的名称。
	默认名字Thread-编号从0开始

static Thread	currentThread() 返回对当前正在执行的线程对象的引用。

设置名字

void	setName(String name) 改变线程名称，使之与参数 name 相同。

还可以通过**Thread**(String name) 分配新的 Thread 对象。设置名称

1
package _19thread01.com.cskaoyan._03api;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 11:38
7
 **/
8
/*
9
设置获取线程名称
10
 */
11
public class GetSetNameDemo {
12
    public static void main(String[] args) {
13
        // 获取主线程的名称
14
        // currentThread()
15
        // 返回对当前正在执行的线程对象的引用。
16
        Thread thread = Thread.currentThread();
17
        System.out.println(thread.getName());
18

19
        // 创建并启动2个线程
20
        MyThread t1 = new MyThread("王道吴彦祖");
21
        MyThread t2 = new MyThread("王道彭于晏");
22

23
        // setName(String name)
24
        // 改变线程名称，使之与参数 name 相同。
25
        //t1.setName("王道吴彦祖");
26
        //t2.setName("王道彭于晏");
27

28

29
        t1.start();
30
        t2.start();
31
    }
32
}
33

34
class MyThread extends Thread{
35
    public MyThread(String name) {
36
        super(name);
37
    }
38

39
    // run
40
    @Override
41
    public void run() {
42
        for (int i = 0; i < 10; i++) {
43
            System.out.println(Thread.currentThread().getName()+"----"+i);
44
        }
45
    }
46
}

线程的调度方式#

什么是线程调度#

概念: 给线程分配CPU处理权的过程

调度方式的分类#

协同式线程调度
- 线程的执行时间由线程本身决定, 当这个线程执行完后报告操作系统,切换到下一个线程
抢占式的线程调度方式
- 线程的执行时间由系统决定, 哪个线程抢到了CPU的执行,哪个线程执行

java中采用哪种调度方式#

Java中采用的是抢占式的调度方式

线程的优先级(了解)#

操作系统优先级#

动态优先级

正在执行的线程会随着执行时间的延长, 优先级降低
正在等待的线程会随着等待的时间的延长,优先级会升高

静态优先级

固定数值

动态优先级+静态优先级

java中优先级#

静态优先级 1-10

static int	MAX_PRIORITY 线程可以具有的最高优先级。10
static int	MIN_PRIORITY 线程可以具有的最低优先级。 1
static int	NORM_PRIORITY 分配给线程的默认优先级。 5

设置获取优先级

int	getPriority() 返回线程的优先级。
void	setpriority(int n) 设置线程优先级

Demo

1
package _19thread01.com.cskaoyan._03api;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 14:38
7
 **/
8
/*
9
获取设置线程优先级
10
 */
11
public class PriorityDemo {
12
    public static void main(String[] args) {
13
        // 创建子类对象
14
        MyThread2 t = new MyThread2();
15
        // setPriority(int n)
16
        //t.setPriority(Thread.MAX_PRIORITY);
17
        t.setPriority(Thread.MIN_PRIORITY);
18

19
        // getPriority()
20
        int priority = t.getPriority();
21
        System.out.println("priority = " + priority);
22
        // start
23
        t.start();
24
    }
25
}
26

27
class MyThread2 extends Thread{
28
    //run
29

30
    @Override
31
    public void run() {
32
        for (int i = 0; i < 10; i++) {
33
            System.out.println(i);
34
        }
35
    }
36

37
}

优先级案例

创建并启动2个线程 A B

A线程设置最大优先级10

B线程设置最小优先级 1

每个线程打印10个数

结论: 做不到A先打印完 B打印完

优先级没有卵用.

然而，我们在java语言中设置的线程优先级，它仅仅只能被看做是一种”建议”(对操作系统的建议)，实际上，操作系统本身，有它自己的一套线程优先级 (静态优先级 + 动态优先级)

java官方：线程优先级并非完全没有用，我们Thread的优先级，它具有统计意义，总的来说，高优先级的线程占用的cpu执行时间多一点，低优先级线程，占用cpu执行时间，短一点

1
package _19thread01.com.cskaoyan._03api;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 14:42
7
 **/
8
/*
9

10

11
优先级案例
12

13
创建并启动2个线程 A  B
14

15
A线程设置最大优先级10
16

17
B线程设置最小优先级 1
18

19
每个线程打印10个数
20
 */
21
public class Ex {
22
    public static void main(String[] args) {
23
        // 创建2个线程
24
        MyThread3 t1 = new MyThread3("A");
25
        MyThread3 t2 = new MyThread3("B");
26

27
        // 设置优先级
28
        t1.setPriority(10);
29
        t2.setPriority(1);
30

31
        // 启动
32
        t1.start();
33
        t2.start();
34
    }
35
}
36

37
class MyThread3 extends Thread{
38
    //run
39

40
    public MyThread3(String name) {
41
        super(name);
42
    }
43

44
    @Override
45
    public void run() {
46
        for (int i = 0; i < 10; i++) {
47
            System.out.println(getName()+"-----"+i);
48
        }
49
    }
50

51
}

线程控制API#

线程休眠sleep#

static void	sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

1
package _19thread01.com.cskaoyan._03api;
2

3
import java.util.concurrent.TimeUnit;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/19 14:50
9
 **/
10
/*
11
线程休眠
12
 */
13
public class SleepDemo {
14
    public static void main(String[] args) {
15
        System.out.println("main start");
16
        //ThreadSleep t = new ThreadSleep();
17
        //t.start();
18
        new ThreadSleep().start();
19

20
        //try {
21
        //    Thread.sleep(3000);
22
        //} catch (InterruptedException e) {
23
        //    e.printStackTrace();
24
        //}
25
        System.out.println("main end");
26

27
    }
28
}
29

30
class ThreadSleep extends Thread{
31
    //run
32

33
    @Override
34
    public void run() {
35
        System.out.println("子线程启动");
36
        for (int i = 0; i < 10; i++) {
37
            System.out.println(i);
38
            // 休眠1s
39
            // TimeUnit.SECONDS.sleep(1) 跟 Thread.sleep(1000)等价
40
            try {
41
                Thread.sleep(1000);
42
                // TimeUnit.SECONDS.sleep(1);
43
            } catch (InterruptedException e) {
44
                e.printStackTrace();
45
            }
46
        }
47
    }
48
}

线程合并join#

void	join() 等待该线程终止。

谁等待?

执行结果上看main线程在等待, join这行代码在哪个线程上运行, 哪个线程等待

等待谁?

执行结果上看等待的是子线程, 哪个线程调用了join, 等待的就是这个线程

1
package _19thread01.com.cskaoyan._03api;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 14:57
7
 **/
8
/*
9
线程加入(合并)
10
 */
11
public class JoinDemo {
12
    public static void main(String[] args) {
13
        System.out.println("main start");
14
        // 创建线程对象
15
        ThreadJoin t = new ThreadJoin();
16

17

18
        // 启动线程
19
        t.start();
20
        // 调用join
21
        try {
22
            t.join();
23
        } catch (InterruptedException e) {
24
            e.printStackTrace();
25
        }
26
        System.out.println("main end");
27

28
    }
29
}
30

31
class ThreadJoin extends Thread{
32
    // run
33

34
    @Override
35
    public void run() {
36
        for (int i = 0; i < 10; i++) {
37
            System.out.println(i);
38
        }
39
    }
40
}

1
没有使用join的输出结果:
2

3
main start
4
main end
5
0
6
1
7
2
8
3
9
4
10
5
11
6
12
7
13
8
14
9
15
使用join后输出结果:
16
main start
17
0
18
1
19
2
20
3
21
4
22
5
23
6
24
7
25
8
26
9
27
main end

线程礼让yield#

static void	yield() 暂停当前正在执行的线程对象，并执行其他线程。

创建并启动2个线程 A B

都是打印10个数

要求A打印0, B打印0, A打印1, B打印1…

结论: 通过yield方法做不到

1
package _19thread01.com.cskaoyan._03api;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 15:10
7
 **/
8
/*
9
线程礼让
10
创建并启动2个线程 A B
11

12
都是打印10个数
13

14
要求A打印0, B打印0, A打印1, B打印1.....
15
 */
16
public class YieldDemo {
17
    public static void main(String[] args) {
18
        // 创建并启动2个线程
19
        new ThreadYield("A").start();
20
        new ThreadYield("B").start();
21
    }
22
}
23

24
class ThreadYield extends Thread{
25
    public ThreadYield(String name) {
26
        super(name);
27
    }
28
    // run
29

30

31
    @Override
32
    public void run() {
33
        for (int i = 0; i < 10; i++) {
34
            System.out.println(getName()+"----"+i);
35
            // 立刻执行yield方法
36
            // 暂停当前正在执行的线程对象，并执行其他线程。
37
            Thread.yield();
38
            // 虽然yield方法使当前线程放弃了CPU的执行权 但是仍然可以参与下轮的CPU的竞争
39
        }
40
    }
41
}

守护线程setDaemon#

线程分类

用户线程(默认)
- 系统的工作线程
守护线程
- 为用户线程服务的线程(GC垃圾回收线程), 系统的后台线程, 可以把它当做用户线程的奴仆

void	setDaemon(boolean on) 将该线程标记为守护线程或用户线程
	on - 如果为 true，则将该线程标记为守护线程。

注意:

当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。 (start之前) java.lang.IllegalThreadStateException

1
package _19thread01.com.cskaoyan._03api;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 15:45
7
 **/
8
/*
9
守护线程
10
 */
11
public class DaemonDemo {
12
    public static void main(String[] args) {
13
        System.out.println("main start");
14

15
        // 创建线程对象
16
        ThreadDaemon t = new ThreadDaemon();
17

18
        // 把t这个线程设置为守护线程
19
        t.setDaemon(true);
20

21
        // start
22
        t.start();
23

24

25
        // main 打印3个数
26
        for (int i = 0; i < 3; i++) {
27
            System.out.println(Thread.currentThread().getName()+
28
                    "----"+i);
29
            try {
30
                Thread.sleep(1000);
31
            } catch (InterruptedException e) {
32
                e.printStackTrace();
33
            }
34
        }
35

36
        System.out.println("main end");
37
    }
38
}
39

40
class ThreadDaemon extends Thread{
41
    @Override
42
    public void run() {
43
        for (int i = 0; i < 10; i++) {
44
            System.out.println(getName()+"----"+i);
45
            try {
46
                Thread.sleep(1000);
47
            } catch (InterruptedException e) {
48
                e.printStackTrace();
49
            }
50
        }
51
    }
52
}

线程中断stop(已过时,了解)#

void	stop() 已过时。该方法具有固有的不安全性

安全中断线程#

案例:

定义一个flag标记, true 是正常状态 false中断

主线程打印3个数打印1个休眠1秒中断子线程

创建子线程打印10个数休眠1秒

打印之前判断一下是否中断如果正常----> 打印数据

如果发生了中断-------> 不在打印, 并且把中断信息保存到log.txt文件中

格式年月日时分秒哪个线程发生了中断

1
package _19thread01.com.cskaoyan._03api;
2

3
import java.io.FileWriter;
4
import java.io.IOException;
5
import java.text.SimpleDateFormat;
6
import java.util.Date;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/19 16:11
12
 **/
13
/*
14
安全的中断线程
15
案例:
16

17
定义一个flag标记, true 是正常状态  false中断
18

19
主线程打印3个数 打印1个 休眠1秒  中断子线程
20

21
创建子线程  打印10个数 休眠1秒
22

23
打印之前判断一下是否中断 如果正常----> 打印数据
24

25
如果发生了中断-------> 不在打印, 并且把中断信息保存到log.txt文件中
26

27
格式 年月日 时分秒  哪个线程发生了中断
28
 */
29
public class SecurityStopDemo {
30
    public static void main(String[] args) {
31
        // 创建线程对象
32
        ThreadStop2 t = new ThreadStop2();
33

34
        // start启动
35
        t.start();
36

37
        for (int i = 0; i < 3; i++) {
38
            System.out.println("main----"+i);
39
            try {
40
                Thread.sleep(1000);
41
            } catch (InterruptedException e) {
42
                e.printStackTrace();
43
            }
44
        }
45
        // 中断子线程
46
        t.flag = false;
47

48
    }
49
}
50

51
class ThreadStop2 extends Thread{
52
    // 定义一个标记
53
    boolean flag = true;
54
    @Override
55
    public void run() {
56
        for (int i = 0; i < 10; i++) {
57
            // 判断是否发生了中断
58
            // 如果正常 正常打印
59
            if (flag) {
60
                System.out.println(getName()+"----"+i);
61
                try {
62
                    Thread.sleep(1000);
63
                } catch (InterruptedException e) {
64
                    e.printStackTrace();
65
                }
66

67
            }else {
68
                // 发生了中断
69
                // 把中断信息保存log.txt文件中
70
                // 创建输出流对象
71
                FileWriter fileWriter = null;
72
                try {
73
                    fileWriter = new FileWriter("log.txt");
74
                    // 创建SimpleDataFormat对象 指定格式
75
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
76
                    String date = sdf.format(new Date());
77
                    // write(String s)
78
                    fileWriter.write(date+getName()+"发生了中断!");
79
                    // 格式 年月日 时分秒  哪个线程发生了中断
80
                    // flush
81
                    fileWriter.flush();
82
                } catch (IOException e) {
83
                    e.printStackTrace();
84
                }finally {
85
                    if (fileWriter != null) {
86
                        try {
87
                            fileWriter.close();
88
                        } catch (IOException e) {
89
                            e.printStackTrace();
90
                        }
91
                    }
92
                }
93
            }
94
        }
95
    }
96
}

线程的生命周期#

线程的几种状态#

理论层面的状态#

新建

刚new出来的线程对象

就绪

线程执行了start()方法后

执行

拥有CPU的执行权

阻塞

线程会处于阻塞状态

死亡

run方法执行完

代码层面的状态#

NEW 至今尚未启动的线程处于这种状态。
RUNNABLE 正在 Java 虚拟机中执行的线程处于这种状态。
BLOCKED 受阻塞并等待某个监视器锁的线程处于这种状态。
WAITING 无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
TIMED_WAITING 等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
TERMINATED 已退出的线程处于这种状态。

线程状态的转换#

多线程实现方式二:实现Runnable接口#

文档示例#

步骤#

定义一个类实现Runnable接口
重写run方法
创建子类对象
创建线程对象, 把实现了Runnable接口的子类对象作为参数传递
start方法启动线程

Demo

1
package _19thread01.com.cskaoyan._04impltwo;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/19 16:40
7
 **/
8
/*
9
多线程的实现方式二:
10
1. 定义一个类实现Runnable接口
11
2. 重写run方法
12
3. 创建子类对象
13
4. 创建线程对象, 把实现了Runnable接口的子类对象作为参数传递
14
5. start方法启动线程
15

16

17
 */
18
public class Demo {
19
    public static void main(String[] args) {
20
        //3. 创建子类对象
21
        MyRunnable myRunnable = new MyRunnable();
22
        // 4. 创建线程对象, 把实现了Runnable接口的子类对象作为参数传递
23
        Thread t = new Thread(myRunnable);
24
        // 5. start方法启动线程
25
        t.start();
26
    }
27
}
28

29
//1. 定义一个类实现Runnable接口
30
class MyRunnable implements Runnable{
31
    @Override
32
    public void run() {
33
        // 2. 重写run方法
34
        System.out.println("子线程执行了!");
35
    }
36
}

其他写法匿名内部类 lambda

1
package _20thread02.com.cskaoyan._01impltwo;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 9:28
7
 **/
8
/*
9
其他写法
10
 */
11
public class Demo {
12
    public static void main(String[] args) {
13
        // 匿名内部类
14
        new Thread(new Runnable() {
15
            @Override
16
            public void run() {
17
                System.out.println("1111");
18
            }
19
        }).start();
20

21
        // lambda
22
        new Thread(()->{
23
            System.out.println("222222");
24
        }).start();
25
    }
26
}

为什么Runnable中的run方法会运行在子线程中#

1
class Thread implements Runnable{
2
    // 成员变量
3
  private Runnable  target;
4

5
    // 构造方法
6
    Thread(Runnable target){
7
        init(target);
8
    }
9
    void init(Runnable target){
10
        // 左边是成员变量 右边是传过来的参数 给成员变量赋值
11
        this.target = target;
12
    }
13

14
    void run(){
15
        if(target != null){
16
            target.run()
17
        }
18
    }
19
}

方式一VS方式二#

步骤上, 方式一4步, 方式二是5步
方式一通过继承的方式(单继承的局限性),方式二通过实现接口的方式
方式二把线程跟线程上要做的事情区分开来(执行路径,跟执行路径上的任务区分开来) 解耦
方式二便于数据共享

多线程仿真如下场景：假设A电影院正在上映某电影，该电影有100张电影票可供出售，现在假设有3个窗口售票。请设计程序模拟窗口售票的场景。

分析： 3个窗口售票，互不影响，同时进行。 -----> 多线程 3个线程 3个窗口共同出售这100张电影票 -------> 多线程共享数据

1
package _20thread02.com.cskaoyan._02datasecurity;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 9:55
7
 **/
8
/*
9
多线程仿真如下场景：
10
假设A电影院正在上映某电影，该电影有100张电影票可供出售，现在假设有3个窗口售票。请设计程序模拟窗口售票的场景。
11

12
分析：
13
3个窗口售票，互不影响，同时进行。
14
3个窗口共同出售这100张电影票
15

16
 */
17
public class Demo2 {
18
    public static void main(String[] args) {
19
        SellWindow2 myRunnable = new SellWindow2();
20
        // 创建3个线程 并启动
21
        Thread t1 = new Thread(myRunnable);
22
        Thread t2 = new Thread(myRunnable);
23
        Thread t3 = new Thread(myRunnable);
24

25
        t1.setName("A窗口");
26
        t2.setName("B窗口");
27
        t3.setName("C窗口");
28

29
        // start
30
        t1.start();
31
        t2.start();
32
        t3.start();
33
    }
34
}
35

36
// 方式二模拟
37
class SellWindow2 implements Runnable{
38
    // 定义成员变量
39
    int tickets = 100;
40

41
    //run
42

43
    @Override
44
    public void run() {
45
        // 卖票
46
        while (true) {
47
            // 分析 重复的票
48
            // 假设ABC3个线程
49
            // 假设A抢到了CPU的执行权 tickets = 100
50
            // 假设B抢到了CPU的执行权 tickets = 100
51
            // C抢到了CPU的执行权    tickets = 100
52

53

54
            // 分析不存在的票
55
            // 假设ABC3个线程
56
            // 假设A抢到了CPU的执行权 tickets = 1
57
            // 假设B抢到了CPU的执行权 tickets = 1
58
            // 假设C抢到了CPU的执行权 tickets = 1
59

60
            // 判断一下 >0 允许卖
61
            if (tickets > 0) {
62
                // A进来  睡觉
63
                // B进来  睡觉
64
                // C进来  睡觉
65
                // 模拟网络延时
66
                try {
67
                    Thread.sleep(100);
68
                } catch (InterruptedException e) {
69
                    e.printStackTrace();
70
                }
71
                System.out.println(Thread.currentThread().getName()+"卖了第"+
72
                        (tickets -- ) + "票");
73

74
                // tickets -- 分为几步?
75
                // 1.取值  2.-1  3.重新赋值
76

77
                // 假设A睡醒  取值100 没来及-1 被抢走了执行权
78
                // B抢到了   取值100 没来及-1  被抢走了执行权
79
                // C抢到了  取值100
80

81

82

83
                // 分析不存在的情况
84
                // 假设A睡醒 A打印 A窗口卖了第1张票  还剩0张
85
                // 假设B睡醒      B窗口卖了第0张票  还剩-1张
86
                // 假设C睡醒      C窗口卖了第-1张票  还剩-2张
87
            }
88
        }
89
    }
90
}

多线程数据安全问题#

造成的现象#

出现重复的票

出现不存在的票

产生原因#

多线程的运行环境(需求)
多线程共享数据(需求)
存在非原子操作
- 原子操作: 一个不可分割的操作(一个操作要么一次执行完, 要么不执行)

解决多线程数据安全问题#

思路: 由产生的原因入手

需求无法更改

只能改非原子操作

引入锁的概念

synchronized#

同步代码块#

同步代码块的锁对象(对象 , 用来充当锁的角色)

可以是任意的对象, 但是要保证是同一个

1
synchronized(锁对象){
2
    // 对共享数据的访问操作
3
}

1
package _20thread02.com.cskaoyan._03sync;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 11:07
7
 **/
8
/*
9
同步代码块
10
 */
11
public class Demo {
12
    public static void main(String[] args) {
13
        SellWindow myRunnable = new SellWindow();
14
        // 创建3个线程 并启动
15
        Thread t1 = new Thread(myRunnable);
16
        Thread t2 = new Thread(myRunnable);
17
        Thread t3 = new Thread(myRunnable);
18

19
        t1.setName("A窗口");
20
        t2.setName("B窗口");
21
        t3.setName("C窗口");
22

23
        // start
24
        t1.start();
25
        t2.start();
26
        t3.start();
27
    }
28
}
29

30
class SellWindow implements Runnable{
31
    // 定义成员变量
32
    int tickets = 100;
33
    // 定义一把锁
34
    //A obj = new A();
35
    Object obj = new Object();
36
    //run
37

38
    @Override
39
    public void run() {
40
        // 卖票
41
        while (true) {
42
            // 锁对象是谁?
43
            synchronized (obj) {
44
                // 对共享数据的访问操作
45
                if (tickets > 0) {
46
                    try {
47
                        Thread.sleep(100);
48
                    } catch (InterruptedException e) {
49
                        e.printStackTrace();
50
                    }
51
                    System.out.println(Thread.currentThread().getName()+"卖了第"+
52
                            (tickets -- ) + "票");
53

54
                }
55
            }
56

57
        }
58
    }
59
}
60

61
class A{}

同步方法#

同步方法的锁对象是this

1
package _20thread02.com.cskaoyan._03sync;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 11:07
7
 **/
8
/*
9
同步方法
10
 */
11
public class Demo2 {
12
    public static void main(String[] args) {
13
        SellWindow2 myRunnable = new SellWindow2();
14
        // 创建3个线程 并启动
15
        Thread t1 = new Thread(myRunnable);
16
        Thread t2 = new Thread(myRunnable);
17
        Thread t3 = new Thread(myRunnable);
18

19
        t1.setName("A窗口");
20
        t2.setName("B窗口");
21
        t3.setName("C窗口");
22

23
        // start
24
        t1.start();
25
        t2.start();
26
        t3.start();
27
    }
28
}
29

30
class SellWindow2 implements Runnable {
31
    // 定义成员变量
32
    int tickets = 100;
33
    // 定义一把锁
34
    //Object obj = new Object();
35
    //B obj = new B();
36
    int i = 0;
37

38
    //run
39

40
    @Override
41
    public void run() {
42
        // 卖票
43
        while (true) {
44
            if (i % 2 == 0) {
45
                synchronized (this) {
46
                    // 对共享数据的访问操作
47
                    if (tickets > 0) {
48
                        try {
49
                            Thread.sleep(100);
50
                        } catch (InterruptedException e) {
51
                            e.printStackTrace();
52
                        }
53
                        System.out.println(Thread.currentThread().getName() + "卖了第" +
54
                                (tickets--) + "票");
55
                    }
56
                }
57
            } else {
58
                sell();
59
            }
60
            i++;
61

62

63
        }
64
    }
65

66
    private synchronized void sell() {
67

68
        // 对共享数据的访问操作
69
        if (tickets > 0) {
70
            try {
71
                Thread.sleep(100);
72
            } catch (InterruptedException e) {
73
                e.printStackTrace();
74
            }
75
            System.out.println(Thread.currentThread().getName() + "卖了第" +
76
                    (tickets--) + "票");
77
        }
78
    }
79

80
}
81

82
class B{}

静态同步方法#

静态同步方法的锁对象是字节码文件对象(Class对象)

1
package _20thread02.com.cskaoyan._03sync;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 11:07
7
 **/
8
/*
9
静态同步方法
10
 */
11
public class Demo3 {
12
    public static void main(String[] args) {
13
        SellWindow3 myRunnable = new SellWindow3();
14
        // 创建3个线程 并启动
15
        Thread t1 = new Thread(myRunnable);
16
        Thread t2 = new Thread(myRunnable);
17
        Thread t3 = new Thread(myRunnable);
18

19
        t1.setName("A窗口");
20
        t2.setName("B窗口");
21
        t3.setName("C窗口");
22

23
        // start
24
        t1.start();
25
        t2.start();
26
        t3.start();
27
    }
28
}
29

30
class SellWindow3 implements Runnable {
31
    // 定义成员变量
32
    static int tickets = 100;
33
    // 定义一把锁
34
    Object obj = new Object();
35
    //B obj = new B();
36
    int i = 0;
37

38
    //run
39

40
    @Override
41
    public void run() {
42
        // 卖票
43
        while (true) {
44
            if (i % 2 == 0) {
45
                synchronized (SellWindow3.class) {
46
                    // 静态的同步方法的锁对象是字节码文件对象 Class对象
47
                    // 对象.getClass()
48
                    // 类名.class属性
49
                    // Class.forName(String 全类名)
50
                    // 对共享数据的访问操作
51
                    if (tickets > 0) {
52
                        try {
53
                            Thread.sleep(100);
54
                        } catch (InterruptedException e) {
55
                            e.printStackTrace();
56
                        }
57
                        System.out.println(Thread.currentThread().getName() + "卖了第" +
58
                                (tickets--) + "票");
59
                    }
60
                }
61
            } else {
62
                sell();
63
            }
64
            i++;
65

66

67
        }
68
    }
69

70
    private static synchronized void sell() {
71

72
        // 对共享数据的访问操作
73
        if (tickets > 0) {
74
            try {
75
                Thread.sleep(100);
76
            } catch (InterruptedException e) {
77
                e.printStackTrace();
78
            }
79
            System.out.println(Thread.currentThread().getName() + "卖了第" +
80
                    (tickets--) + "票");
81
        }
82
    }
83

84
}

synchronized的细节#

执行流程#

AB2个线程访问sync代码块中的内容
假设A线程抢到了CPU的执行权, 看一下锁对象是否可用, 可用, A线程就持有了锁对象, A线程访问同步代码块的内容
A还没有访问结束,发生了线程切换,B抢到了执行权,B也想访问同步代码块中的内容, 看一下锁是否可用, 不可用, 对于B线程来说, 只能在sync外面等待, B就处于同步阻塞状态
A再次抢到执行权. A接着执行,访问结束, 退出sync代码块, A释放锁
B线程就可以获取锁, 访问sync代码块中的内容.

1
package _20thread02.com.cskaoyan._03sync;
2

3
import java.util.concurrent.TimeUnit;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/20 11:38
9
 **/
10
/*
11
synchronized执行流程
12
 */
13
public class Demo4 {
14
    // 定义一把锁
15
    public static final Object OBJECT = new Object();
16
    public static void main(String[] args) {
17
        // 创建并启动一个线程
18
        new Thread(()->{
19
            // sync
20
            synchronized (OBJECT) {
21
                System.out.println("A进入sync");
22

23
                // 休眠
24
                try {
25
                    TimeUnit.SECONDS.sleep(10);
26
                } catch (InterruptedException e) {
27
                    e.printStackTrace();
28
                }
29

30
                System.out.println("A退出sync");
31
            }
32
        },"A").start();
33
        // main睡眠1秒
34
        try {
35
            Thread.sleep(1000);
36
        } catch (InterruptedException e) {
37
            e.printStackTrace();
38
        }
39

40
        // 创建并启动一个线程
41
        new Thread(()->{
42
            System.out.println("B线程执行了!");
43
            // sync
44
            synchronized (OBJECT) {
45
                System.out.println("B进入sync!");
46
            }
47
        },"B").start();
48
    }
49
}

出现异常会释放锁#

1
package _20thread02.com.cskaoyan._03sync;
2

3
import java.util.concurrent.TimeUnit;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/20 14:29
9
 **/
10
/*
11
验证异常会释放锁
12
 */
13
public class Demo5 {
14
    // 定义一把锁
15
    public static final Object OBJECT = new Object();
16
    public static int count = 0;
17
    public static void main(String[] args) {
18
        // 创建并启动一个线程
19
        new Thread(()->{
20
            // sync
21
            synchronized (OBJECT) {
22
                System.out.println("A线程进入sync");
23
                while (true) {
24
                    count++;
25
                    try {
26
                        TimeUnit.SECONDS.sleep(1);
27
                    } catch (InterruptedException e) {
28
                        e.printStackTrace();
29
                    }
30
                    if (count == 5) {
31
                        System.out.println(count);
32
                        // 人为制造异常
33
                        System.out.println(10/0);
34
                    }
35

36
                }
37
            }
38
        },"A").start();
39
        // sleep
40
        try {
41
            Thread.sleep(1000);
42
        } catch (InterruptedException e) {
43
            e.printStackTrace();
44
        }
45

46
        // 创建并启动一个线程
47
        new Thread(()->{
48
            System.out.println("B线程已经执行了");
49
            // sync
50
            synchronized (OBJECT) {
51
                System.out.println("B线程进入sync");
52
            }
53
        },"B").start();
54

55
    }
56
}

1个对象的内存布局#

2条字节码指令(monitorenter/monitorexit)#

Lock#

基本使用

void	lock() 获取锁。
void	unlock() 释放锁

ReentrantLock可重入锁#

一个可重入的互斥锁 Lock，它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。

1
package _20thread02.com.cskaoyan._04lock;
2

3
import java.util.concurrent.locks.Lock;
4
import java.util.concurrent.locks.ReentrantLock;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/20 15:02
10
 **/
11
/*
12
Lock的使用
13
 */
14
public class Demo {
15
    public static void main(String[] args) {
16
        SellWindow myRunnable = new SellWindow();
17
        // 创建3个线程 并启动
18
        Thread t1 = new Thread(myRunnable);
19
        Thread t2 = new Thread(myRunnable);
20
        Thread t3 = new Thread(myRunnable);
21

22
        t1.setName("A窗口");
23
        t2.setName("B窗口");
24
        t3.setName("C窗口");
25

26
        // start
27
        t1.start();
28
        t2.start();
29
        t3.start();
30
    }
31
}
32
class SellWindow implements Runnable{
33
    // 定义成员变量
34
    int tickets = 100;
35
    // 定义一把锁
36
    Lock lock = new ReentrantLock();
37
    //run
38

39
    @Override
40
    public void run() {
41
        // 卖票
42
        while (true) {
43
            // 加锁, 获取锁
44
            lock.lock();
45
            try {
46
                if (tickets > 0) {
47

48
                    try {
49
                        Thread.sleep(100);
50
                    } catch (InterruptedException e) {
51
                        e.printStackTrace();
52
                    }
53
                    System.out.println(Thread.currentThread().getName()+"卖了第"+
54
                            (tickets -- ) + "票");
55

56
                }
57
            }finally {
58
                // 释放锁
59
                lock.unlock();
60
            }
61

62

63
        }
64
    }
65
}

synchronized VS Lock

synchronized是关键字, Lock是个接口
synchronized是一把隐式的锁, 加锁和释放锁是由jvm自动完成的. Lock它是一把真正的(显式的)锁, 我们能看到加锁跟释放锁的过程(lock() , unlock())

死锁#

什么是死锁#

2个或以上线程因为争抢资源而造成的互相等待的现象

死锁产生的场景#

一般出现在同步代码块嵌套

1
synchronized(objA){
2
    synchronized(objB){
3

4
}
5
}

1
package _20thread02.com.cskaoyan._05dielock;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 15:17
7
 **/
8

9
public class Demo {
10
    public static void main(String[] args) {
11
        // 创建并启动2个线程
12
        new Thread(new DieLock(true)).start();
13
        new Thread(new DieLock(false)).start();
14
    }
15
}
16
//定义一个锁类
17
class MyLock{
18
    public static final Object objA = new Object();
19
    public static final Object objB = new Object();
20
}
21

22
// 死锁类
23
class DieLock implements Runnable{
24
    boolean flag;
25

26
    public DieLock(boolean flag) {
27
        this.flag = flag;
28
    }
29

30
    @Override
31
    public void run() {
32
        // 同步代码块嵌套
33
        if (flag) {
34
            synchronized (MyLock.objA) {
35
                // 假设A线程先执行 A线程获取A锁
36
                System.out.println("if A");
37
                synchronized (MyLock.objB) {
38
                    System.out.println("if B");
39
                }
40
            }
41
        }else{
42
            synchronized (MyLock.objB) {
43
                // B线程进来 获取了B锁
44
                System.out.println("else B");
45
                synchronized (MyLock.objA) {
46
                    System.out.println("else A");
47
                }
48
            }
49
        }
50
    }
51
}

怎么解决死锁#

更改加锁的顺序

1
package _20thread02.com.cskaoyan._05dielock;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 15:17
7
 **/
8

9
public class Demo2 {
10
    public static void main(String[] args) {
11
        // 创建并启动2个线程
12
        new Thread(new DieLock2(true)).start();
13
        new Thread(new DieLock2(false)).start();
14
    }
15
}
16

17
//定义一个锁类
18
class MyLock2{
19
    public static final Object objA = new Object();
20
    public static final Object objB = new Object();
21
}
22

23
// 死锁类
24
class DieLock2 implements Runnable{
25
    boolean flag;
26

27
    public DieLock2(boolean flag) {
28
        this.flag = flag;
29
    }
30

31
    @Override
32
    public void run() {
33
        // 同步代码块嵌套
34
        if (flag) {
35
            synchronized (MyLock2.objA) {
36
                // 假设A线程先执行 A线程获取A锁
37
                System.out.println("if A");
38
                synchronized (MyLock2.objB) {
39
                    System.out.println("if B");
40
                }
41
            }
42
        }else{
43
            synchronized (MyLock2.objA) {
44
                // B线程进来 获取了B锁
45
                System.out.println("else B");
46
                synchronized (MyLock2.objB) {
47
                    System.out.println("else A");
48
                }
49
            }
50
        }
51
    }
52
}

再加一把锁, 变成原子操作

1
package _20thread02.com.cskaoyan._05dielock;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/20 15:17
7
 **/
8

9
public class Demo3 {
10
    public static void main(String[] args) {
11
        // 创建并启动2个线程
12
        new Thread(new DieLock3(true)).start();
13
        new Thread(new DieLock3(false)).start();
14
    }
15
}
16

17
//定义一个锁类
18
class MyLock3{
19
    public static final Object objA = new Object();
20
    public static final Object objB = new Object();
21
    // 新加的锁
22
    public static final Object objC = new Object();
23
}
24

25
// 死锁类
26
class DieLock3 implements Runnable{
27
    boolean flag;
28

29
    public DieLock3(boolean flag) {
30
        this.flag = flag;
31
    }
32

33
    @Override
34
    public void run() {
35
        // 同步代码块嵌套
36
        if (flag) {
37
            synchronized (MyLock3.objC) {
38
                synchronized (MyLock3.objA) {
39
                    // 假设A线程先执行 A线程获取A锁
40
                    System.out.println("if A");
41
                    synchronized (MyLock3.objB) {
42
                        System.out.println("if B");
43
                    }
44
                }
45
            }
46

47
        }else{
48
            synchronized (MyLock3.objC) {
49
                synchronized (MyLock3.objB) {
50
                    // B线程进来 获取了B锁
51
                    System.out.println("else B");
52
                    synchronized (MyLock3.objA) {
53
                        System.out.println("else A");
54
                    }
55
                }
56
            }
57
        }
58
    }
59
}

生产者消费者模型#

V1 使用同步代码块

1
package _20thread02.com.cskaoyan._07producer_consumer.v1;
2

3

4
// 定义蒸笼类
5
public class Box {
6
    // 定义成员变量
7
    Food food;
8

9
    // 定义方法
10
    // 生产包子的方法 只有生产者才执行
11
    public void setFood(Food newFood) {
12
        // 表示放入包子
13
        food = newFood;
14
        System.out.println(Thread.currentThread().getName() +
15
                "生产了" + food);
16
    }
17

18
    // 吃包子的方法  只有消费者执行
19
    public void eatFood() {
20
        System.out.println(Thread.currentThread().getName() +
21
                "吃了" + food);
22
        food = null;
23
    }
24

25
    // 判断蒸笼状态的方法
26
    public boolean isEmpty() {
27
        return food == null;
28
        // true  ---> 空
29
        // false ---> 非空
30
    }
31

32
}
33

34
// 定义包子类
35
class Food{
36
    // 成员变量
37
    String name;
38
    int price;
39

40
    public Food(String name, int price) {
41
        this.name = name;
42
        this.price = price;
43
    }
44

45
    @Override
46
    public String toString() {
47
        return "Food{" +
48
                "name='" + name + '\'' +
49
                ", price=" + price +
50
                '}';
51
    }
52
}
53

54

55

56

57
package _20thread02.com.cskaoyan._07producer_consumer.v1;
58

59

60

61
public class ConsumerTask implements Runnable {
62
    // 成员变量
63
    Box box;
64

65
    public ConsumerTask(Box box) {
66
        this.box = box;
67
    }
68

69
    @Override
70
    public void run() {
71
        // 吃包子
72
        while (true) {
73
            synchronized (box) {
74
                //判断蒸笼状态
75
                if (box.isEmpty()) {
76
                    // 如果蒸笼为空 ,
77
                    // 没有包子阻止自己吃包子
78
                    //   wait
79
                    try {
80
                        box.wait();
81
                    } catch (InterruptedException e) {
82
                        e.printStackTrace();
83
                    }
84

85
                }else {
86
                    // 如果蒸笼非空 , 有包子
87
                    // 消费吃包子通知生产者再生产
88
                    box.eatFood();
89
                    // notify
90
                    box.notify();
91

92
                }
93
            }
94
        }
95
    }
96
}
97

98

99

100

101
package _20thread02.com.cskaoyan._07producer_consumer.v1;
102

103
import java.util.Random;
104

105

106

107
public class ProducerTask implements Runnable{
108
    // 成员变量
109
    Box box;
110
    Food[] foods = {new Food("韭菜鸡蛋", 1),
111
            new Food("生蚝包", 10),
112
            new Food("羊腰子包", 20)};
113
    Random random = new Random();
114

115
    public ProducerTask(Box box) {
116
        this.box = box;
117
    }
118

119
    @Override
120
    public void run() {
121
        // 生产包子
122
        while (true) {
123
            synchronized (box) {
124
                // 判断蒸笼的状态
125
                if (box.isEmpty()) {
126
                    // 如果蒸笼为空, 没有包子生产包子 放进去
127
                    int index = random.nextInt(foods.length);
128
                    box.setFood(foods[index]);
129
                    // 通知消费者吃 notify
130
                    box.notify();
131

132
                }else{
133
                    // 如果蒸笼非空, 有包子 生产者不能生产
134
                    // 阻止自己生产 wait
135
                    try {
136
                        box.wait();
137
                    } catch (InterruptedException e) {
138
                        e.printStackTrace();
139
                    }
140

141
                }
142
            }
143
        }
144
    }
145
}
146

147

148
package _20thread02.com.cskaoyan._07producer_consumer.v1;
149

150

151

152
public class Demo {
153
    public static void main(String[] args) {
154
        // 创建蒸笼对象
155
        Box box = new Box();
156
        // 创建生产者任务
157
        ProducerTask producerTask = new ProducerTask(box);
158
        // 创建消费者任务
159
        ConsumerTask consumerTask = new ConsumerTask(box);
160
        // 创建生产者线程
161
        Thread t1 = new Thread(producerTask);
162
        // 创建消费者线程
163
        Thread t2 = new Thread(consumerTask);
164

165
        t1.setName("生产者");
166
        t2.setName("消费者");
167

168
        // 启动
169
        t1.start();
170
        t2.start();
171
    }
172
}

V2 使用同步方法

1
package _20thread02.com.cskaoyan._07producer_consumer.v2;
2

3

4
public class Box {
5
    Food food;
6

7
    // 生产包子的方法 生产者执行
8
    public synchronized void setFood(Food newFood) {
9
        // 判断蒸笼的状态
10
        if (food == null) {
11
            // 如果蒸笼为空,
12
            // 没有包子生产包子 放进去通知消费者吃
13
            food = newFood;
14
            System.out.println(Thread.currentThread().getName()+
15
                    "生产了"+food);
16
            //  notify
17
            this.notify();
18

19
        }else{
20
            // 如果蒸笼非空, 有包子生产者不能生产 阻止自己生产
21
            // wait
22
            try {
23
                this.wait();
24
            } catch (InterruptedException e) {
25
                e.printStackTrace();
26
            }
27
        }
28
    }
29

30

31
    // 吃包子的方法  消费者执行
32
    public synchronized void eatFood() {
33
        // 判断蒸笼状态
34
        if (food == null) {
35
            // 如果蒸笼为空 , 没有包子阻止自己吃包子
36
            //   wait
37
            try {
38
                this.wait();
39
            } catch (InterruptedException e) {
40
                e.printStackTrace();
41
            }
42
        }else {
43
            // 如果蒸笼非空 , 有包子
44
            // 消费吃包子通知生产者再生产
45
            System.out.println(Thread.currentThread().getName()+
46
                    "吃了"+food);
47
            food = null;
48
            // notify
49
            this.notify();
50

51
        }
52
    }
53
}
54

55
class Food{
56
    String name;
57
    int price;
58

59
    @Override
60
    public String toString() {
61
        return "Food{" +
62
                "name='" + name + '\'' +
63
                ", price=" + price +
64
                '}';
65
    }
66

67
    public Food(String name, int price) {
68
        this.name = name;
69
        this.price = price;
70
    }
71
}
72

73
package _20thread02.com.cskaoyan._07producer_consumer.v2;
74

75

76

77
public class ConsumerTask implements Runnable {
78
    Box box;
79

80
    public ConsumerTask(Box box) {
81
        this.box = box;
82
    }
83

84
    @Override
85
    public void run() {
86
        // 只吃包子
87
        while (true) {
88
            box.eatFood();
89
        }
90
    }
91
}
92

93

94
package _20thread02.com.cskaoyan._07producer_consumer.v2;
95

96
import java.util.Random;
97

98
public class ProducerTask implements Runnable {
99
    Box box;
100

101
    public ProducerTask(Box box) {
102
        this.box = box;
103
    }
104

105
    Food[] foods = {new Food("豆沙包", 1),
106
            new Food("小笼包", 6),
107
            new Food("狗不理", 40)};
108

109
    Random random = new Random();
110
    @Override
111
    public void run() {
112
        // 只做一件事 生产包子
113
        while (true) {
114
            int index = random.nextInt(foods.length);
115
            box.setFood(foods[index]);
116

117
        }
118
    }
119
}
120

121
package _20thread02.com.cskaoyan._07producer_consumer.v2;
122

123
public class Demo {
124
    public static void main(String[] args) {
125
        // 创建蒸笼对象
126
        Box box = new Box();
127
        // 创建生产者任务
128
        ProducerTask producerTask = new ProducerTask(box);
129
        // 创建消费者任务
130
        ConsumerTask consumerTask = new ConsumerTask(box);
131
        // 创建生产者线程
132
        Thread t1 = new Thread(producerTask);
133
        // 创建消费者线程
134
        Thread t2 = new Thread(consumerTask);
135

136
        t1.setName("生产者");
137
        t2.setName("消费者");
138

139
        // 启动
140
        t1.start();
141
        t2.start();
142
    }
143
}

当有多个生产多个消费者的时候, 出现”卡顿”的现象, 为什么?

1
c1,c2,p1,p2  都start
2
c1抢到 > 进入sync , 空的, wait ,释放锁
3
c2抢到  > 进入sync,空的, wait , 释放锁
4
p1抢到  > 进入sync, 空的可以生产, notify唤醒c1 , 退出sync,释放锁
5
p1又抢到 > 进入sync, 非空, wait, 释放锁
6
p2抢到> 进入sync, 非空, wait 释放锁
7
c1抢到 > 进入sync, 非空,吃, notify 唤醒c2 ,退出sync 释放锁
8
c2 > 进入 sync, 空, wait 释放锁
9
c1 > 进入 sync, 空 , wait
10
到此 所有线程都wait
11

12
怎么解决?
13
notifyAll

线程间通信#

wait与notify机制#

wait与notify机制

拥有相同锁的线程才可以实现wait/notify机制，所以后面的描述中都是假定操作同一个锁。

wait()方法是Object类的方法，它的作用是使当前执行wait()方法的线程等待，在wait()所在的代码行处暂停执行，并释放锁，直到接到通知被唤醒。在调用wait()之前，线程必须获得锁对象，即只能在同步方法或同步块中调用wait()方法。如果调用wait()时没有持有适当的锁，则抛出 IllegalMonitorStateException，它是 RuntimeException的一个子类，因此不需要try-catch语句捕捉异常。
notify()方法要在同步方法或同步块中调用，即在调用前，线程必须获得锁对象，如果调用notify() 时没有持有适当的锁，则会抛IllegalMonitorStateException。该方法用来通知那些可能等待该锁对象的其他线程，如果有多个线程等待，则唤醒其中随机一个线程，并使该线程重新获取锁。
需要说明的是，执行notify()方法后，当前线程不会马上释放该锁，因wait方法而阻塞的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized 同步区域后，当前线程才会释放锁，而处于阻塞状态的线程才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕后，它会释放该对象锁，此时如果没有再次使用notify语句，那么其他呈阻塞状态的线程因为没有得到通知，会继续处于阻塞状态。

总结：wait()方法使线程暂停运行，而notify() 方法通知暂停的线程继续运行

wait()#

1
    1. 阻塞功能：
2
        当在某线程中，对象上.wait(), 在哪个线程中调用wait(), 导致哪个线程处于阻塞状态
3
        当某线程，因为调用执行某对象的wait(),而处于阻塞状态，我们说，该线程在该对象上阻塞。
4
    2. 唤醒条件
5
       当某线程，因为某对象A的wait(), 而处于阻塞状态时，如果要唤醒该线程，只能在其他线程中，
6
       再同一个对象(即对象A)上调用其notify()或notifyAll()
7
       即在线程的阻塞对象上，调用notify或notifyAll方法，才能唤醒，在该对象上阻塞的线程
8
    3. 运行条件
9
          当前线程必须拥有此对象监视器。
10
          监视器：指synchronized代码块中的锁对象
11
        即我们只能在，当前线程所持有的synchronized代码块中的，锁对象上调用wait方法，
12
        才能正常执行
13
        如果没有锁对象就会有这样一个异常 IllegalMonitorStateException
14
    4. 执行特征
15
          a.该线程发布(release)对此监视器的所有权
16
          b.等待(阻塞)
17
       注意：Thread的sleep方法，执行的时候：
18
            该线程不丢失任何监视器的所属权

执行条件与特点#

执行条件

需要锁对象

1
package _20thread02.com.cskaoyan._06wait_notify;
2

3

4
/*
5
使用条件
6
 */
7
public class Demo {
8
    public static void main(String[] args) {
9
        // 对象.wait()
10
        Object o = new Object();
11
        try {
12
            o.wait();
13
        } catch (InterruptedException e) {
14
            e.printStackTrace();
15
        }
16
        // java.lang.IllegalMonitorStateException
17
    }
18
}

执行特点

1
package _20thread02.com.cskaoyan._06wait_notify;
2

3

4
/*
5
执行特点
6
 */
7
public class Demo2 {
8
    public static void main(String[] args) {
9
        // 对象.wait()
10
        Object o = new Object();
11
        synchronized (o) {
12
            try {
13
                System.out.println("wait before");
14
                o.wait();
15
                System.out.println("wait after");
16

17
            } catch (InterruptedException e) {
18
                e.printStackTrace();
19
            }
20
            /*
21
            输出结果:
22
            wait before
23
            main线程处于阻塞状态
24
            想要after打印出来, 必须在别的线程中, 同一个锁对象上调用notify方法唤醒
25
             */
26
        }
27
    }
28
}

验证wait释放锁#

1
package _20thread02.com.cskaoyan._06wait_notify;
2

3

4
/*
5
wait方法释放锁
6
 */
7
public class Demo3 {
8
    // 定义一把锁
9
    public static final Object OBJECT = new Object();
10
    public static void main(String[] args) {
11
        // 创建并启动一个线程
12
        new Thread(()->{
13
            // sync
14
            synchronized (OBJECT) {
15
                System.out.println("A线程进入sync");
16
                try {
17
                    Thread.sleep(10000);
18
                    System.out.println("wait before");
19
                    OBJECT.wait();
20
                    System.out.println("wait after");
21

22
                } catch (InterruptedException e) {
23
                    e.printStackTrace();
24
                }
25
            }
26
        },"A").start();
27
        // sleep
28
        try {
29
            Thread.sleep(1000);
30
        } catch (InterruptedException e) {
31
            e.printStackTrace();
32
        }
33

34
        // 创建并启动一个线程
35
        new Thread(()->{
36
            System.out.println("B线程已经执行了");
37
            // sync
38
            synchronized (OBJECT) {
39
                System.out.println("B线程进入sync!");
40
            }
41
        },"B").start();
42

43
    }
44
}

wait与notify的基本使用#

1
package _20thread02.com.cskaoyan._06wait_notify;
2

3

4
/*
5
wait notify的基本使用
6
 */
7
public class Demo4 {
8
    // 定义一把锁
9
    public static final Object OBJECT = new Object();
10
    public static void main(String[] args) {
11
        // 创建并启动一个线程
12
        new Thread(()->{
13
            // sync
14
            synchronized (OBJECT) {
15
                System.out.println("A进入sync");
16
                // 调用wait
17
                try {
18
                    Thread.sleep(5000);
19
                    System.out.println("wait before");
20
                    OBJECT.wait();
21
                    System.out.println("wait after");
22

23
                } catch (InterruptedException e) {
24
                    e.printStackTrace();
25
                }
26
            }
27
        },"A").start();
28
        // sleep
29
        try {
30
            Thread.sleep(1000);
31
        } catch (InterruptedException e) {
32
            e.printStackTrace();
33
        }
34

35
        // 创建并启动一个线程
36
        new Thread(()->{
37
            System.out.println("B已经执行了");
38
            // sync
39
            synchronized (OBJECT) {
40
                System.out.println("B进入sync");
41
                // 调用notify
42
                System.out.println("notify before");
43
                OBJECT.notify();
44
                System.out.println("notify after");
45

46
                try {
47
                    Thread.sleep(5000);
48
                } catch (InterruptedException e) {
49
                    e.printStackTrace();
50
                }
51
            }
52
        },"B").start();
53

54
    }
55
}

练习

创建2个线程A B

A线程打印1,B线程打印2, A线程打印3, B打印4… B线程打印100(使用wait notify)

1
package _20thread02.com.cskaoyan._06wait_notify;
2

3

4
/*
5
练习
6

7
创建2个线程A  B
8

9
A线程打印1,B线程打印2, A线程打印3, B打印4.... B线程打印100(使用wait notify)
10
 */
11
public class Ex {
12
    // 定义一把锁
13
    public static final Object OBJECT = new Object();
14
    public static void main(String[] args) {
15
        // 创建A线程 1 3 5....99
16
        new Thread(()->{
17
            // sync
18
            synchronized (OBJECT) {
19
                for (int i = 1; i < 100; i+=2) {
20
                    // 唤醒另一个线程
21
                    OBJECT.notify();
22
                    // 打印
23
                    System.out.println(Thread.currentThread().getName()+
24
                            "----"+i);
25
                    // 阻止自己打印 wait
26
                    try {
27
                        OBJECT.wait();
28
                    } catch (InterruptedException e) {
29
                        e.printStackTrace();
30
                    }
31
                }
32
                // notify 把对方唤醒
33
                OBJECT.notify();
34

35
            }
36
        },"A").start();
37
        // sleep
38
        try {
39
            Thread.sleep(100);
40
        } catch (InterruptedException e) {
41
            e.printStackTrace();
42
        }
43

44
        // 创建B线程 2 4 6.....100
45
        new Thread(()->{
46
            // sync
47
            synchronized (OBJECT) {
48
                for (int i = 2; i <= 100; i+=2) {
49
                    // 唤醒另一个线程
50
                    OBJECT.notify();
51
                    // 打印
52
                    System.out.println(Thread.currentThread().getName()+
53
                            "----"+i);
54
                    // 阻止自己打印 wait
55
                    try {
56
                        OBJECT.wait();
57
                    } catch (InterruptedException e) {
58
                        e.printStackTrace();
59
                    }
60
                }
61
                // notify()唤醒对象
62
                OBJECT.notify();
63

64
            }
65
        },"B").start();
66
    }
67
}

sleep VS wait#

1
Thread.sleep VS Object.wait()
2

3
1. 所属不同：
4
   a. sleep定义在Thread类，静态方法
5
   b. wait定义在 Object类中，非静态方法
6

7
2. 唤醒条件不同
8
   a. sleep: 休眠时间到
9
   b. wait: 在其他线程中，在同一个锁对象上，调用了notify或notifyAll方法
10

11
3. 使用条件不同：
12
   a. sleep 没有任何前提条件
13
   b. wait(), 必须当前线程，持有锁对象，锁对象上调用wait()
14

15
4. 休眠时，对锁对象的持有，不同：（最最核心的区别）
16
   a. 线程因为sleep方法而处于阻塞状态的时候，在阻塞的时候不会放弃对锁的持有
17
   b. 但是wait()方法，会在阻塞的时候，放弃锁对象持有

notify()#

唤醒在此对象监视器上等待的单个线程。
如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。
选择是任意性的

notifyAll()#

唤醒多个等待的线程

为什么wait,notify,notifyAll方法不定义在Thread类中?#

任意Java对象都能充当锁的角色

完整的线程状态转换图#

理论层面#

代码层面#

多线程工具#

线程池#

线程池（Thread Pool）是一种基于池化技术的并发执行模式，主要用来管理线程的创建、销毁和任务分配，以提高程序执行效率和资源利用率。线程池在处理大量短生命周期的任务时尤为有用，因为它减少了线程创建和销毁的开销。

1
Thread t = new Thread();
2
t.start();
3
Thread t1 = new Thread();
4
t1.start();

线程工具类中提供的3种线程池#

Executors: 线程工具类, 负责产生线程池

ExecutorServices: 代表线程池对象

1
//JDK5提供了一Executors来产生线程池，有如下方法：
2
ExecutorService newCachedThreadPool()
3
// 特点:
4
// 1.会根据需要创建新线程，也可以自动删除，60s处于空闲状态的线程
5
// 2.线程数量可变，立马执行提交的异步任务（异步任务：在子线程中执行的任务）
6
ExecutorService newFixedThreadPool(int nThreads)
7
// 特点:
8
// 1.线程数量固定
9
// 2.维护一个无界队列（暂存已提交的来不及执行的任务）
10
// 3.按照任务的提交顺序，将任务执行完毕
11
ExecutorService newSingleThreadExecutor()
12
// 特点:
13
// 1.单个线程
14
// 2.维护了一个无界队列（暂存已提交的来不及执行的任务）
15
// 3.按照任务的提交顺序，将任务执行完毕

线程池的使用

Future<?> submit(Runnable task)
Future submit(Callable task)

Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。

计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法

Future 用来存储返回值的结果(Callable是带返回值的)

1
// 如有必要，等待计算完成，然后获取其结果
2
V get()

Runnable类型的任务

1
package _21thread03.com.cskaoyan._01threadpool;
2

3
import java.util.concurrent.ExecutorService;
4
import java.util.concurrent.Executors;
5

6

7
/*
8
向线程池中提交Runnable类型的任务
9
 */
10
public class Demo {
11
    public static void main(String[] args) {
12
        // 创建线程池
13
        ExecutorService pool = Executors.newCachedThreadPool();
14
        // 提交任务
15
        // submit(Runnable task)
16
        pool.submit(new RunnableTask());
17
        pool.submit(new RunnableTask());
18
    }
19
}
20

21
class RunnableTask implements Runnable{
22

23
    @Override
24
    public void run() {
25
        for (int i = 0; i < 10; i++) {
26
            System.out.println(Thread.currentThread().getName()+
27
                    "----"+i);
28
        }
29
    }
30
}

提交Callable类型的任务

1
package _21thread03.com.cskaoyan._01threadpool;
2

3
import java.util.concurrent.*;
4

5

6
/*
7
提交Callable类型的任务
8
 */
9
public class Demo2 {
10
    public static void main(String[] args) throws ExecutionException, InterruptedException {
11
        // 创建线程池
12
        ExecutorService pool = Executors.newFixedThreadPool(2);
13
        // 提交任务
14
        // submit(Callable task)
15
        Future<String> future = pool.submit(new CallableTask());
16
        // 接收返回值
17
        // get()
18
        System.out.println("get before");
19
        String s = future.get();
20
        System.out.println("get after");
21

22
        System.out.println(s);
23

24
    }
25
}
26

27
class CallableTask implements Callable<String>{
28
    @Override
29
    public String call() throws Exception {
30
        for (int i = 0; i < 10; i++) {
31
            System.out.println(i);
32
        }
33
        TimeUnit.SECONDS.sleep(10);
34
        return "Call执行结束";
35
    }
36

37
    //@Override
38
    //public Object call() throws Exception {
39
    //    return null;
40
    //}
41
}

关闭线程池

1
// 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
2
shutdown()
3
// 试图停止所有正在执行的活动任务，暂停处理正在等待的任务。
4
shutdownNow()

多线程的实现方式三:实现Callable接口#

不借助线程池

需要借助FutureTask

FutureTask = Future + Task

构造方法

1
// 创建一个 FutureTask，一旦运行就执行给定的 Callable。
2
FutureTask(Callable<V> callable)

继承关系

基本使用

1
package _21thread03.com.cskaoyan._02call;
2

3
import java.util.concurrent.Callable;
4
import java.util.concurrent.ExecutionException;
5
import java.util.concurrent.FutureTask;
6

7
/*
8
使用Callable
9
 */
10
public class Demo {
11
    public static void main(String[] args) throws ExecutionException, InterruptedException {
12
        // 创建FutureTask对象
13
        FutureTask<String> futureTask = new FutureTask<>(new MyCallable());
14
        // 创建线程对象
15
        Thread t = new Thread(futureTask);
16
        // start
17
        t.start();
18
        // get() 获取结果
19
        String s = futureTask.get();
20
        System.out.println(s);
21

22
    }
23
}
24

25
class MyCallable implements Callable<String> {
26

27
    @Override
28
    public String call() throws Exception {
29
        System.out.println("call执行了");
30
        return "1234";
31
    }
32
}

练习

创建2个线程,A线程计算1+2+3…+100的结果

B线程计算1+2+3+…200的结果

使用Callable

1
package _21thread03.com.cskaoyan._02call;
2

3
import java.util.concurrent.Callable;
4
import java.util.concurrent.ExecutionException;
5
import java.util.concurrent.FutureTask;
6

7
/*
8
练习
9

10
创建2个线程,A线程计算1+2+3...+100的结果
11

12
B线程计算1+2+3+...200的结果
13

14
使用Callable
15
 */
16
public class Ex {
17
    public static void main(String[] args) throws ExecutionException, InterruptedException {
18
        // 创建FutureTask对象
19
        FutureTask<Integer> futureTask1 = new FutureTask<>(new SumTask(100));
20
        FutureTask<Integer> futureTask2 = new FutureTask<>(new SumTask(200));
21
        // 创建线程对象
22
        Thread t1 = new Thread(futureTask1);
23
        Thread t2 = new Thread(futureTask2);
24
        // start启动
25
        t1.start();
26
        t2.start();
27
        // get方法获取计算的结果
28
        Integer result1 = futureTask1.get();
29
        Integer result2 = futureTask2.get();
30
        System.out.println("result1 = " + result1);
31
        System.out.println("result2 = " + result2);
32
    }
33
}
34

35
class SumTask implements Callable<Integer> {
36
    // 成员变量
37
    int num;
38

39
    public SumTask(int num) {
40
        this.num = num;
41
    }
42

43
    @Override
44
    public Integer call() throws Exception {
45
        // 计算
46
        int sum =0;
47
        for (int i = 1; i <= num ; i++) {
48
            sum+=i;
49
        }
50
        return sum;
51
    }
52
}

Runnable VS Callable

Runnable里是run方法, Callable里是call方法
Runnable没有返回值, Callable有返回值

线程池核心参数#

ThreadPoolExecutor 是 Java 中 java.util.concurrent 包提供的一个强大的线程池实现。

它实现了 ExecutorService 接口，提供了一种灵活的线程池管理机制，允许程序员自行设置线程池中的核心参数.

1
public class ThreadPoolExecutor extends AbstractExecutorService {
2
    // 核心线程数
3
    private volatile int corePoolSize;
4
    // 最大线程数
5
    private volatile int maximumPoolSize;
6
  // 阻塞队列
7
    private final BlockingQueue<Runnable> workQueue;
8
    // 存活时间
9
    private volatile long keepAliveTime;
10
    // 拒绝策略
11
    private volatile RejectedExecutionHandler handler;
12
    // 默认拒绝策略
13
  private static final RejectedExecutionHandler defaultHandler =
14
        new AbortPolicy();
15

16
}

线程池参数配置：

corePoolSize：核心线程数，即使它们处于空闲状态，线程池也会尽力维持该数量的线程。
maximumPoolSize：线程池允许创建的最大线程数。
keepAliveTime：当线程数超过核心线程数时，这是超出数量的空闲线程在终止前等待新任务的最长时间。
unit：keepAliveTime 的时间单位。
workQueue：任务队列，用于存放待执行任务的阻塞队列

任务拒绝策略

AbortPolicy：抛出 RejectedExecutionException(默认情况)。
CallerRunsPolicy：直接在调用者线程中运行任务。
DiscardPolicy：丢弃无法处理的任务。
DiscardOldestPolicy：丢弃队列中最旧的未处理任务，并尝试再次提交当前任务

线程池执行流程#

每次往线程池中提交任务的时候，有如下的处理流程：

step1：判断当前线程数是否大于或等于corePoolSize。如果小于，则新建线程执行；如果大于，则进入step2。

step2：判断队列是否已满。如未满，则放入；如已满，则进入step3。

step3：判断当前线程数是否大于或等于maxPoolSize。如果小于，则新建线程执行；如果大于，则进入step4。

step4：根据拒绝策略，拒绝任务。

总结一下：首先判断corePoolSize，其次判断blockingQueue是否已满，接着判断maxPoolSize，最后使用拒绝策略。

定时器与定时任务#

定时器Timer#

一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。

构造方法

1
// 创建一个新计时器。
2
Timer()

调度方法

1
schedule(TimerTask task, Date time)
2
schedule(TimerTask task, long delay, long period)
3
schedule(TimerTask task, Date firstTime, long period)
4
scheduleAtFixedRate(TimerTask task, long delay, long period)
5

6
schedule  VS scheduleAtFixedRate 区别
7
追赶特性

取消计时器

1
// 终止此计时器，丢弃所有当前已安排的任务。
2
void cancel()

定时任务TimerTask#

1
public abstract class TimerTask
2
//由 Timer 安排为一次执行或重复执行的任务

如何使用:

定义一个任务继承TimerTask
重写run方法

1
package _21thread03.com.cskaoyan._03timer;
2

3
import java.text.ParseException;
4
import java.text.SimpleDateFormat;
5
import java.util.Date;
6
import java.util.Timer;
7
import java.util.TimerTask;
8
import java.util.concurrent.TimeUnit;
9

10

11
public class Demo {
12
    public static void main(String[] args) throws ParseException, InterruptedException {
13
        // 创建定时器
14
        Timer timer = new Timer();
15
        // 调度
16
        // schedule(TimerTask task, Date time)
17
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
18
        String time = "2022-10-21 11:48:00";
19
        Date date = sdf.parse(time);
20
        // timer.schedule(new MyTask(), date);
21

22
        //schedule(TimerTask task, long delay, long period)
23
        timer.schedule(new MyTask(),5000,3000);
24

25
        //schedule(TimerTask task, Date firstTime, long period)
26
        //timer.schedule(new MyTask(), date, 3000);
27

28
        //scheduleAtFixedRate(TimerTask task, long delay, long period)
29
        // 取消定时器
30
        TimeUnit.SECONDS.sleep(15);
31
        timer.cancel();
32
    }
33
}
34
// 定义一个定时任务
35
// 继承TimerTask
36
// 重写run
37
class MyTask extends TimerTask{
38

39
    @Override
40
    public void run() {
41
        System.out.println("炸弹爆炸了Boom!");
42
    }
43
}

单例设计模式补充(线程安全)#

构造方法私有
提供一个全局的自身的成员变量
提供一个静态的方法获取实例

同步方法

1
package com.cskaoyan._04singleton;
2

3

4
public class Singleton {
5

6
    //2. 提供一个全局的自身的成员变量
7
    private static Singleton instance;
8
    // 1. 构造方法私有
9

10
    private Singleton() {
11
    }
12

13
    //3. 提供一个静态的方法获取实例
14
    public  static synchronized Singleton getInstance() {
15
        if (instance == null) {
16
            instance = new Singleton();
17
        }
18
        return instance;
19
    }
20
}

double check

1
package com.cskaoyan._04singleton;
2

3

4
public class Singleton2 {
5

6
    //2. 提供一个全局的自身的成员变量
7
    private static Singleton2 instance;
8
    // 1. 构造方法私有
9

10
    private Singleton2() {
11
    }
12

13
    //3. 提供一个静态的方法获取实例
14
    public  static Singleton2 getInstance() {
15

16
        // double check
17
        if (instance == null) {
18
            // 假设A线程抢到了CPU执行权 A执行
19
            // A持有锁对象
20
            // 切换B线程 B执行
21
            // B没有锁 进入不了sync
22
            synchronized (Singleton2.class) {
23
                // A线程进来
24
                // B进来了
25
                // 第二次校验
26
                if (instance == null) {
27
                    instance = new Singleton2();
28

29
                }
30
            }
31
        }
32
        return instance;
33
    }
34
}

Java 基础语法：多线程

引例:单线程不能满足”同时”的需求#

操作系统基本概念#

进程(process)与线程(thread)#

串行(serial),并行(parallel)与并发(concurrency)#

同步(synchronization)与异步(asynchronization)#

java程序运行原理#

java命令+主类类名运行原理#

jvm是单线程还是多线程的#

多线程的实现方式一:继承Thread类#

文档示例#

步骤#

注意事项#

设置获取线程名称#

线程的调度方式#

什么是线程调度#

调度方式的分类#

java中采用哪种调度方式#

线程的优先级(了解)#

操作系统优先级#

java中优先级#

线程控制API#

线程休眠sleep#

线程合并join#

线程礼让yield#

守护线程setDaemon#

线程中断stop(已过时,了解)#

安全中断线程#

线程的生命周期#

线程的几种状态#

理论层面的状态#

代码层面的状态#

线程状态的转换#

多线程实现方式二:实现Runnable接口#

文档示例#

步骤#

为什么Runnable中的run方法会运行在子线程中#

方式一VS方式二#

多线程数据安全问题#

造成的现象#

产生原因#

解决多线程数据安全问题#

synchronized#

同步代码块#

同步方法#

静态同步方法#

synchronized的细节#

执行流程#

出现异常会释放锁#

1个对象的内存布局#

2条字节码指令(monitorenter/monitorexit)#

Lock#

ReentrantLock可重入锁#

死锁#

什么是死锁#

死锁产生的场景#

怎么解决死锁#

生产者消费者模型#

线程间通信#

wait与notify机制#

wait()#

执行条件与特点#

验证wait释放锁#

wait与notify的基本使用#

sleep VS wait#

notify()#

notifyAll()#

为什么wait,notify,notifyAll方法不定义在Thread类中?#

完整的线程状态转换图#

理论层面#

代码层面#

多线程工具#

线程池#

线程工具类中提供的3种线程池#

多线程的实现方式三:实现Callable接口#

线程池核心参数#

线程池执行流程#

定时器与定时任务#

定时器Timer#

定时任务TimerTask#