每一年都奔走在自己热爱里

没有人是一座孤岛，总有谁爱着你

第8章 多线程

8.1 线程简介

1 、多任务

  • 现实生活中多件事一起作。

  • 在程序中是指在一个系统中可以同时进行多个进程，即有多个单独运行的任务，每一个任务对应一个进程。

  • 每一个进程都有一段专用的内存区域，即使是多次启动同一段程序产生不同的进程也是如此。

2、多线程

  • Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

  • 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。

  • 多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。

  • 主线程和子线程交替执行

3、程序、进程、线程

  • 程序

    • 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

  • 进程

    • 一个应用程序（1个进程是一个软件）

    • 是执行程序的一次执行过程，是一个流动的概念。是系统资源分配的单位。

    • 一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。

  • 线程

    • 一个进程中的执行场景/执行单元。

    • 线程是CPU调度和执行的单位。

    • 一个线程不能独立的存在，它必须是进程的一部分。

  • 注意：

    • 一个进程可以有多个线程

    • 线程是独立的执行路径。

    • 在程序与运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程

    • main（）称为主线程，为系统的入口，用于执行整个程序；

    • 在一个进程中，如果开辟了多个进程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。

    • 对于同一份资源操作，会存在资源抢夺的问题，需要加入并发控制。

    • 线程会带来额外的开销，CPU的调度时间、并发控制开销。

    • 每一个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

8.2 线程创建

  • 三种创建方式：

    • Thread class 继承Thread类

    • Runnable接口 实现Runnable接口

    • Callable接口 实现Callable接口

8.2.1 Thread类

  1. 创建一个新的执行线程的方法，将一个声明为Thread的子类。

  2. 自定义线程类继承Thread类

  3. 重写run（）方法，编写线程执行体

  4. 创建线程对象，调用start（）方法启动线程。

  5. 注意：

    • 线程开启不一定立即执行，由CPU调度执行

    • 启动线程：子类对象.start（）

    • 不建议使用，为了避免OOP单继承的局限性

  6. 实例

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/20
 6  * JavaSE
 7  * 创建多线程  继承Thread类
 8  */
 9 public class TestThread1 extends Thread{
10     @Override
11     public void run() {
12         for (int i = 0; i < 20; i++) {
13             System.out.println("我在看代码-----"+i);
14         }
15     }
16 ​
17     public static void main(String[] args) {
18         //main 主线程
19 ​
20         //创建一个线程对象
21         TestThread1 testThread1 = new TestThread1();
22 ​
23         //调用start()方法开启线程
24         testThread1.start();
25         for (int i = 0; i < 20; i++) {
26             System.out.println("我在学习多线程---"+i);
27         }
28     }
29 }
30 ​
31 //多条执行路径，主线程和子线程并行交替执行
32 ​
33 执行结果：
34 我在学习多线程---0
35 我在看代码-----0
36 我在学习多线程---1
37 我在看代码-----1
38 我在学习多线程---2
39 我在看代码-----2
40 我在看代码-----3
41 我在学习多线程---3
42 我在看代码-----4
43 我在看代码-----5
44 我在学习多线程---4
45 我在学习多线程---5
46 我在看代码-----6
47 我在学习多线程---6
48 我在看代码-----7
49 我在学习多线程---7
50 我在看代码-----8
51 我在学习多线程---8
52 我在看代码-----9
53 我在学习多线程---9
54 我在看代码-----10
55 我在学习多线程---10
56 我在学习多线程---11
57 我在学习多线程---12
58 我在学习多线程---13
59 我在学习多线程---14
60 我在学习多线程---15
61 我在学习多线程---16
62 我在学习多线程---17
63 我在学习多线程---18
64 我在学习多线程---19
65 我在看代码-----11
66 我在看代码-----12
67 我在看代码-----13
68 我在看代码-----14
69 我在看代码-----15
70 我在看代码-----16
71 我在看代码-----17
72 我在看代码-----18
73 我在看代码-----19

     

8.2.2 Runnable

  1. 创建一个线程是声明实现类Runnable接口

  2. 定义MyRunable类实现Runnable接口

  3. 实现run（）方法，编写线程执行体

  4. 创建线程对象，调用start（）方法启动线程

  5. 注意：

    • 启动线程：传入目标对象+Thread对象.start（）

    • 推荐使用，避免单继承局限性，灵活方便，方便同一个对象被多个线程使用。

  6. 实例：

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/20
 6  * JavaSE
 7  * 实现Runnable接口线程
 8  */
 9 public class TestThread2 implements Runnable{
10     
11     //重写方法
12     @Override
13     public void run() {
14         for (int i = 0; i < 20; i++) {
15             System.out.println("我在看代码-----"+i);
16         }
17     }
18 ​
19     public static void main(String[] args) {
20         //main 主线程
21 ​
22         //创建一个线程对象
23         TestThread2 testThread2 = new TestThread2();
24         //代理,通过线程对象来开启线程
25         Thread thread = new Thread(testThread2);
26         thread.start();
27         for (int i = 0; i < 20; i++) {
28             System.out.println("我在学习多线程---"+i);
29         }
30     }
31 }
32 ​
33 ​
34 ​
35 执行结果：
36 我在学习多线程---0
37 我在学习多线程---1
38 我在看代码-----0
39 我在学习多线程---2
40 我在看代码-----1
41 我在学习多线程---3
42 我在看代码-----2
43 我在学习多线程---4
44 我在学习多线程---5
45 我在学习多线程---6
46 我在看代码-----3
47 我在学习多线程---7
48 我在学习多线程---8
49 我在学习多线程---9
50 我在学习多线程---10
51 我在学习多线程---11
52 我在学习多线程---12
53 我在学习多线程---13
54 我在学习多线程---14
55 我在学习多线程---15
56 我在学习多线程---16
57 我在学习多线程---17
58 我在学习多线程---18
59 我在看代码-----4
60 我在学习多线程---19
61 我在看代码-----5
62 我在看代码-----6
63 我在看代码-----7
64 我在看代码-----8
65 我在看代码-----9
66 我在看代码-----10
67 我在看代码-----11
68 我在看代码-----12
69 我在看代码-----13
70 我在看代码-----14
71 我在看代码-----15
72 我在看代码-----16
73 我在看代码-----17
74 我在看代码-----18
75 我在看代码-----19

     

  7. 案例：

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/20
 6  * JavaSE
 7  *多个线程同时操作同一个对象
 8  * 买火车票的例子
 9  */
10 public class TestThread4 implements Runnable{
11 ​
12     private int a = 10;
13 ​
14     @Override
15     public void run() {
16         while (true){
17             if (a<=0){
18                 break;
19             }
20             System.out.println(Thread.currentThread().getName()+"拿到了"+a--+"票");
21         }
22 ​
23     }
24 ​
25     public static void main(String[] args) {
26         TestThread4 b = new TestThread4();
27         new Thread(b,"小明").start();
28         new Thread(b,"老师").start();
29         new Thread(b,"黄牛").start();
30         new Thread(b,"警察").start();
31     }
32 }
33 ​
34 执行结果：
35 小明拿到了9票
36 老师拿到了8票
37 警察拿到了7票
38 黄牛拿到了10票
39 警察拿到了4票
40 警察拿到了2票
41 警察拿到了1票
42 老师拿到了5票
43 小明拿到了6票
44 黄牛拿到了3票
45 ​

     

  8. 实例：龟兔赛跑

      1 package Demo032;
  2 ​
  3 /**
  4  * @Author: H-YONG-8
  5  * @DATA: 2023/4/20
  6  * JavaSE
  7  * 龟兔赛跑
  8  * 首先来个赛道距离，然后要离距离越来越近
  9  * 判断比赛是否结束
 10  * 打印出胜利者
 11  * 龟兔赛跑开始
 12  * 模拟兔子睡觉
 13  * 乌龟赢得比赛
 14  */
 15 public class TestThread3 implements Runnable{
 16 ​
 17     //胜利者
 18     private static String winner;
 19 ​
 20     @Override
 21     public void run() {
 22 ​
 23         //跑步开始
 24         for (int i = 0; i <= 100; i++) {
 25 ​
 26             //模拟兔子睡觉
 27             if(Thread.currentThread().getName().equals("兔子") && i%10 == 0){
 28                 try {
 29                     Thread.sleep(1);
 30                 } catch (InterruptedException e) {
 31                     e.printStackTrace();
 32                 }
 33 ​
 34             }
 35 ​
 36             //判断比赛是否结束
 37             boolean flag = gameOver(i);
 38             //如果比赛结束了，就停止程序
 39             if(flag){
 40                 break;
 41             }
 42             System.out.println(Thread.currentThread().getName()+"---->跑了"+i+"步");
 43         }
 44 ​
 45     }
 46 ​
 47     //判断是否完成比赛
 48     private boolean gameOver(int steps){
 49         //判断是否有胜利者
 50         if(winner!=null){//已经存在胜利者
 51             return true;
 52         }{
 53             if (steps >= 100){
 54                 winner = Thread.currentThread().getName();
 55                 System.out.println("winner ="+winner);
 56                 return true;
 57             }
 58         }
 59         return false;
 60     }
 61 ​
 62     public static void main(String[] args) {
 63 ​
 64         //设置赛道
 65         TestThread3 race = new TestThread3();
 66 ​
 67         new Thread(race,"兔子").start();
 68         new Thread(race,"乌龟").start();
 69 ​
 70     }
 71 }
 72 ​
 73 ​
 74 运行结果：
 75 乌龟---->跑了0步
 76 乌龟---->跑了1步
 77 乌龟---->跑了2步
 78 乌龟---->跑了3步
 79 乌龟---->跑了4步
 80 乌龟---->跑了5步
 81 乌龟---->跑了6步
 82 乌龟---->跑了7步
 83 乌龟---->跑了8步
 84 乌龟---->跑了9步
 85 乌龟---->跑了10步
 86 乌龟---->跑了11步
 87 乌龟---->跑了12步
 88 乌龟---->跑了13步
 89 乌龟---->跑了14步
 90 乌龟---->跑了15步
 91 乌龟---->跑了16步
 92 乌龟---->跑了17步
 93 乌龟---->跑了18步
 94 乌龟---->跑了19步
 95 乌龟---->跑了20步
 96 乌龟---->跑了21步
 97 乌龟---->跑了22步
 98 乌龟---->跑了23步
 99 乌龟---->跑了24步
100 乌龟---->跑了25步
101 乌龟---->跑了26步
102 乌龟---->跑了27步
103 乌龟---->跑了28步
104 乌龟---->跑了29步
105 乌龟---->跑了30步
106 乌龟---->跑了31步
107 乌龟---->跑了32步
108 乌龟---->跑了33步
109 乌龟---->跑了34步
110 乌龟---->跑了35步
111 乌龟---->跑了36步
112 乌龟---->跑了37步
113 乌龟---->跑了38步
114 乌龟---->跑了39步
115 乌龟---->跑了40步
116 乌龟---->跑了41步
117 乌龟---->跑了42步
118 乌龟---->跑了43步
119 乌龟---->跑了44步
120 乌龟---->跑了45步
121 乌龟---->跑了46步
122 乌龟---->跑了47步
123 乌龟---->跑了48步
124 乌龟---->跑了49步
125 乌龟---->跑了50步
126 乌龟---->跑了51步
127 乌龟---->跑了52步
128 乌龟---->跑了53步
129 乌龟---->跑了54步
130 乌龟---->跑了55步
131 乌龟---->跑了56步
132 乌龟---->跑了57步
133 兔子---->跑了0步
134 乌龟---->跑了58步
135 兔子---->跑了1步
136 兔子---->跑了2步
137 兔子---->跑了3步
138 兔子---->跑了4步
139 兔子---->跑了5步
140 兔子---->跑了6步
141 兔子---->跑了7步
142 兔子---->跑了8步
143 兔子---->跑了9步
144 乌龟---->跑了59步
145 乌龟---->跑了60步
146 乌龟---->跑了61步
147 乌龟---->跑了62步
148 乌龟---->跑了63步
149 乌龟---->跑了64步
150 乌龟---->跑了65步
151 乌龟---->跑了66步
152 乌龟---->跑了67步
153 乌龟---->跑了68步
154 乌龟---->跑了69步
155 乌龟---->跑了70步
156 乌龟---->跑了71步
157 乌龟---->跑了72步
158 乌龟---->跑了73步
159 乌龟---->跑了74步
160 乌龟---->跑了75步
161 乌龟---->跑了76步
162 乌龟---->跑了77步
163 乌龟---->跑了78步
164 乌龟---->跑了79步
165 乌龟---->跑了80步
166 乌龟---->跑了81步
167 乌龟---->跑了82步
168 乌龟---->跑了83步
169 乌龟---->跑了84步
170 乌龟---->跑了85步
171 乌龟---->跑了86步
172 乌龟---->跑了87步
173 乌龟---->跑了88步
174 乌龟---->跑了89步
175 乌龟---->跑了90步
176 乌龟---->跑了91步
177 乌龟---->跑了92步
178 乌龟---->跑了93步
179 乌龟---->跑了94步
180 乌龟---->跑了95步
181 乌龟---->跑了96步
182 乌龟---->跑了97步
183 乌龟---->跑了98步
184 兔子---->跑了10步
185 兔子---->跑了11步
186 兔子---->跑了12步
187 兔子---->跑了13步
188 兔子---->跑了14步
189 兔子---->跑了15步
190 兔子---->跑了16步
191 兔子---->跑了17步
192 兔子---->跑了18步
193 兔子---->跑了19步
194 乌龟---->跑了99步
195 winner =乌龟

     

8.2.3 实现Callable接口

  1. 实现Callable接口，需要返回值类型

  2. 重写call方法，需要抛出异常

  3. 创建目标对象

  4. 创建执行服务：ExecutorService ser =Executors.newFixedThreadPool(1);

  5. 提交执行:Futre < Boolean>result1 =ser.submit(t1);

  6. 获取结果:boolean r1 = result1.get()

  7. 关闭服务:ser.shutdownNow();

  8. 实例

     1  public class CallableTest {
 2       public static void main(String[] args) throws ExecutionException, InterruptedException,TimeoutException{
 3           //创建一个线程池
 4           ExecutorService executor = Executors.newCachedThreadPool();
 5           Future<String> future = executor.submit(()-> {
 6                   TimeUnit.SECONDS.sleep(5);
 7                   return "CallableTest";
 8           });
 9           System.out.println(future.get());
10           executor.shutdown();
11       }
12   }
13 ​

     

8.3 lamda表达式和静态代理模式

8.3.1 lamda表达式

  1. 希腊字母表中排序第十一位的字母，英文名为Lambda

  2. 避免匿名内部类定义过多。

  3. 代理模式其实就是通过一个类去代替另一个类去做一些操作。

  4. 其实质属于函数式编程的概念

    （params） ->expression[表达式]
    （params） ->statement[语句]
    （params） ->{statements}

  5. 为什么要用lambda表达式

    • 避免匿名内部内定义过多

    • 代码更加简洁

    • 去掉没有意义的代码，只留下核心代码

  6. Functional Interface（函数式接口）是lamda表达式的关键。

    • 函数式接口：任何接口，如果只包含唯一一个抽象的方法，那他就是函数式接口

  7. 实例：

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  * 推导lambda表达式
 8  */
 9 public class TestThread5 {
10 ​
11     //3静态内部类,实现类
12     static class Like2 implements Ilike{
13         @Override
14         public void lambda(){
15             System.out.println("i like lambda2");
16         }
17     }
18 ​
19     public static void main(String[] args) {
20         Ilike like = new Like();
21         like.lambda();
22 ​
23         like=new Like2();
24         like.lambda();
25 ​
26 ​
27         //4局部内部类
28         class Like3 implements Ilike{
29             @Override
30             public void lambda(){
31                 System.out.println("i like lambda3");
32             }
33         }
34         like=new Like3();
35         like.lambda();
36 ​
37         //5匿名内部类
38         like = new  Ilike() {
39             @Override
40             public void lambda() {
41                 System.out.println("i like lambda4");
42             }
43         };
44         like.lambda();
45 ​
46         //6用lambda简化
47         like = ()->{
48             System.out.println("i like lambda5");
49         };
50         like.lambda();
51 ​
52     }
53 }
54 ​
55 //1定义一个函数式接口
56 interface Ilike{
57     void lambda();
58 }
59 //2实现类
60 class Like implements Ilike{
61     @Override
62     public void lambda(){
63         System.out.println("i like lambda");
64     }
65 }
    ​

  8. 总结：

    • lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，就要用代码块包裹

    • 前提是函数式接口，只有一个方法。

    • 多个参数类型也可以去掉参数类型，要去掉都要去掉。

8.3.2 静态代理模式

  1. 为其他对象提供一个代理以控制对这个对象的访问。

  2. 主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

  3. 代理模式的元素是：共同接口、代理对象、目标对象。

  4. 代理模式的行为：由代理对象执行目标对象的方法、由代理对象扩展目标对象的方法。

  5. 代理模式的宏观特性：对客户端只暴露出接口，不暴露它以下的架构。

  6. 好处多多：中间隔离了一层，更加符合开闭原则

  7. 流程图

    img

  8. 实例：

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  */
 8 public class TeatThread6 {
 9 ​
10     public static void main(String[] args) {
11         WeddingCompany weddingCompany = new WeddingCompany(new You());
12         weddingCompany.HappyMarry();
13     }
14 }
15 ​
16 interface Marry{
17     void HappyMarry();
18 }
19 ​
20 //真实角色
21 class You implements Marry{
22     @Override
23     public void HappyMarry() {
24         System.out.println("小明要结婚了");
25     }
26 }
27 ​
28 //代理角色，帮助结婚
29 class WeddingCompany implements Marry{
30 ​
31     //代理真实角色
32     private Marry target;
33     //构造函数
34     public WeddingCompany(Marry target) {
35         this.target = target;
36     }
37 ​
38     @Override
39     public void HappyMarry() {
40 ​
41         before();
42         this.target.HappyMarry();//这就是真实对象
43         after();
44     }
45 ​
46     private void after() {
47         System.out.println("结婚之后");
48     }
49 ​
50     private void before() {
51         System.out.println("结婚前");
52     }
53 }
54 ​

     

  9. 总结：

    • 真实对象和代理对象都要事先同一个接口

    • 代理对象要代理真实角色，

    • 好处：

      • 代理对象可以做真实对象做不了的事情

      • 真实对象专注于自己的事情

8.4 线程状态

  • 线程五大状态

img

img

  • 线程方法

    方法说明
    setPriority(int newPriority) 更改现成的优先级
    static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
    void join() 等待线程终止
    static void yield() 暂停当前正在执行的线程对象，并执行其他的线程
    void interrupt() 中断线程，不要用这个方法
    boolean isAliven() 测试线程是否处于活动状态

8.4.1 停止线程

  1. 不推荐使用JDK提供的stop()、destory()方法。

  2. 推荐让线程自己停下来

  3. 建议使用一个标志未进行终止变量当flag=false,则终止线程运行。

  4. 测试停止线程

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  * 测试停止线程
 8  * 注意死循环
 9  */
10 public class TestStop implements Runnable{
11 ​
12     //1.设置一个标识位
13     private boolean flag = true;
14 ​
15     //重写方法
16     @Override
17     public void run() {
18         int i = 0;
19         while (flag){
20             System.out.println("线程正在运行"+i++);
21         }
22     }
23 ​
24     //2设置一个公开的方法，停止线程,转换标志位
25     public void stop(){
26         this.flag = false;
27     }
28 ​
29     public static void main(String[] args) {
30 ​
31         TestStop testStop = new TestStop();
32         new Thread(testStop).start();
33 ​
34         for (int i = 0; i < 1000; i++) {
35             System.out.println("main"+i);
36             if(i == 900){
37                 //调用stop方法，切换标志位，让线程停止
38                 testStop.stop();
39                 System.out.println("线程该停止了");
40             }
41         }
42     }
43 }

     

8.4.2 线程休眠

  1. sleep(时间)指定当前线程阻塞的毫秒数；

  2. sleep存在异常InterruptedExcepiton；

  3. sleep时间到达后线程进入就绪状态；

  4. sleep可以模拟网络延迟，倒计时等

  5. 每一个对象都有一个锁，sleep不会释放锁

  6. 倒计时实例

     1 package Demo032;
 2 ​
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 ​
 6 /**
 7  * @Author: H-YONG-8
 8  * @DATA: 2023/4/21
 9  * JavaSE
10  */
11 public class TestSleep2 {
12     public static void main(String[] args) throws InterruptedException {
13         tenDwon();
14 ​
15     //模拟倒计时
16     public static void tenDwon() throws InterruptedException {
17         int num = 10;
18 ​
19         while (true){
20             Thread.sleep(1000);
21             System.out.println(num--);
22             if (num<=0){
23                 break;
24             }
25         }
26     }
27 }
28 ​

     

  7. 获取当前时间

     1 package Demo032;
 2 ​
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 ​
 6 /**
 7  * @Author: H-YONG-8
 8  * @DATA: 2023/4/21
 9  * JavaSE
10  */
11 public class TestSleep2 {
12     public static void main(String[] args){ 
13         //获取系统当前时间
14         Date startTime = new Date(System.currentTimeMillis());
15         while (true) {
16             try {
17                 Thread.sleep(1000);
18                 //更新系统时间
19                 System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
20                 startTime = new Date(System.currentTimeMillis());
21             } catch (InterruptedException e) {
22                 e.printStackTrace();
23             }
24         }
25 ​
26     }
27 }
    ​

8.4.3 线程礼让

  1. 礼让线程，让当前正在执行的线程暂停，但不阻塞

  2. 将线程从运行状态转为就绪状态

  3. 让CPU重新调度，礼让不一定成功

  4. 实例

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  * 礼让线程
 8  */
 9 public class TestYield {
10 ​
11     public static void main(String[] args) {
12         MyYield myYield = new MyYield();
13         new Thread(myYield,"a").start();
14         new Thread(myYield,"b").start();
15 ​
16     }
17 }
18 ​
19 class MyYield implements Runnable{
20     @Override
21     public void run() {
22         System.out.println(Thread.currentThread().getName()+"线程开始执行");
23         Thread.yield();//礼让
24         System.out.println(Thread.currentThread().getName()+"线程停止执行");
25     }
26 }

     

8.4.4 Join（插队）

  1. Join合并线程，待此线程执行完成后，在执行其他的线程，其他的线程阻塞

  2. 可以想象为插队

  3. 实例

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  * 插队
 8  */
 9 public class TestJoin implements Runnable{
10     @Override
11     public void run() {
12         for (int i = 0; i < 1000; i++) {
13             System.out.println("线程VIP来了"+i);
14         }
15     }
16 ​
17     public static void main(String[] args) throws InterruptedException {
18         
19         //启动线程
20         TestJoin testJoin = new TestJoin();
21         Thread thread =new Thread(testJoin);
22         thread.start();
23         
24         //主线程
25         for (int i = 0; i < 500; i++) {
26             if(i == 200){
27                 thread.join();//插队
28             }
29             System.out.println("main"+i);
30         }
31     }
32 }

     


    ​

8.4.5 线程状态观测

  • 线程状态

  1. new：尚未启动的线程处于此状态。

  2. RUNNABLE：在JAVA虚拟机中执行的线程处于此状态。

  3. BLOCKED：被阻塞等待监视器锁定的线程处于此状态。

  4. WAITING：正在等待另一个线程执行特定动作的线程处于此状态。

  5. TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

  6. TERMINATED：已退出的线程处于此状态。

  • 一个线程可以在给定的时间处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

  • 实例

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  */
 8 public class TestState {
 9 ​
10     public static void main(String[] args) throws InterruptedException {
11         Thread thread = new Thread(()->{
12             for (int i = 0; i < 5; i++) {
13                 try {
14                     Thread.sleep(1000);
15                 } catch (InterruptedException e) {
16                     e.printStackTrace();
17                 }
18             }
19             System.out.println("////");
20         });
21         
22         //观察状态
23         Thread.State state= thread.getState();
24         System.out.println(state);//new
25 ​
26         //观察启动后
27         thread.start();//启动线程
28         state = thread.getState();
29         System.out.println(state);//run
30 ​
31         while (state != Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
32             Thread.sleep(100);
33             state = thread.getState();//跟新线程状态
34             System.out.println(state);
35         }
36 ​
37     }
38 }
39 ​
40 ​
41 运行结果
42 NEW
43 RUNNABLE
44 TIMED_WAITING
45 TIMED_WAITING
46 TIMED_WAITING
47 TIMED_WAITING
48 TIMED_WAITING
49 TIMED_WAITING
50 TIMED_WAITING
51 TIMED_WAITING
52 TIMED_WAITING
53 TIMED_WAITING
54 TIMED_WAITING
55 TIMED_WAITING
56 TIMED_WAITING
57 TIMED_WAITING
58 TIMED_WAITING
59 TIMED_WAITING
60 TIMED_WAITING
61 TIMED_WAITING
62 TIMED_WAITING
63 TIMED_WAITING
64 TIMED_WAITING
65 TIMED_WAITING
66 TIMED_WAITING
67 TIMED_WAITING
68 TIMED_WAITING
69 TIMED_WAITING
70 TIMED_WAITING
71 TIMED_WAITING
72 TIMED_WAITING
73 TIMED_WAITING
74 TIMED_WAITING
75 TIMED_WAITING
76 TIMED_WAITING
77 TIMED_WAITING
78 TIMED_WAITING
79 TIMED_WAITING
80 TIMED_WAITING
81 TIMED_WAITING
82 TIMED_WAITING
83 TIMED_WAITING
84 TIMED_WAITING
85 TIMED_WAITING
86 TIMED_WAITING
87 TIMED_WAITING
88 TIMED_WAITING
89 TIMED_WAITING
90 ////
91 TERMINATED

     

8.4.6 线程优先级

  1. Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪一个线程来执行。

  2. 线程的优先级用数字表示，范围从1~10.

    • Thread.MIN_PRIORITY = 1;

    • Thread.MAX_PRIORITY = 10;

    • Thread.NORM_PRIORITY =5;

  3. 使用以下方式改变或者获取优先级

    • getPriority().setPriority(int xxx)

  4. 实例

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  * 测试线程优先级
 8  */
 9 public class TestPriority {
10 ​
11     public static void main(String[] args) {
12         System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
13 ​
14         MyPriority myPriority = new MyPriority();
15         Thread t1 = new Thread(myPriority);
16         Thread t2 = new Thread(myPriority);
17         Thread t3 = new Thread(myPriority);
18         Thread t4 = new Thread(myPriority);
19         Thread t5 = new Thread(myPriority);
20         Thread t6 = new Thread(myPriority);
21 ​
22         //先设置优先级
23         t1.start();
24 ​
25         t2.setPriority(1);
26         t2.start();
27 ​
28         t3.setPriority(4);
29         t3.start();
30 ​
31         t4.setPriority(Thread.MAX_PRIORITY);
32         t4.start();
33 ​
34         t5.setPriority(8);
35         t5.start();
36 ​
37         t6.setPriority(3);
38         t6.start();
39     }
40 ​
41 }
42 class MyPriority implements Runnable{
43 ​
44     @Override
45     public void run() {
46         System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
47     }
48 }
49 ​

     

8.4.7 守护线程

  1. 线程分为用户线程和守护线程

  2. 虚拟机必须确保用户线程执行完毕

  3. 虚拟机不用等待守护线程执行完毕

  4. 实例

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/21
 6  * JavaSE
 7  * 测试守护线程
 8  */
 9 public class TestDaemon {
10     public static void main(String[] args) {
11         God god = new God();
12         You1 you = new You1();
13         Thread thread = new Thread(god);
14         thread.setDaemon(true);
15 ​
16         thread.start();
17         new Thread(you).start();
18     }
19 ​
20 }
21 ​
22 //上帝
23 class God implements Runnable{
24     @Override
25     public void run() {
26         while (true){
27             System.out.println("上帝保佑着你");
28         }
29     }
30 }
31 ​
32 ​
33 //你
34 class You1  implements Runnable{
35     @Override
36     public void run() {
37         for (int i = 0; i < 365000; i++) {
38             System.out.println("你一生都开心的活着");
39         }
40         System.out.println("====goodbye!word!=======");
41     }
42 }

8.5 线程同步

8.5.1 并发

  1. 并发：同一个对象被多个线程同时操作。

  2. 所谓并发编程是指在一台处理器上 “同时” 处理多个任务。并发是在同一实体上的多个事件。多个事件在同一时间间隔发生。

  3. 并发编程，从程序设计的角度来说，是希望通过某些机制让计算机可以在一个时间段内，执行多个任务。从计算机 CPU 硬件层面来说，是一个或多个物理 CPU 在多个程序之间多路复用，提高对计算机资源的利用率。从调度算法角度来说，当任务数量多于 CPU 的核数时，并发编程能够通过操作系统的任务调度算法，实现多个任务一起执行。

  4. 并发编程有三大特性：

    • 原子性；

    • 可见性；

    • 有序性。

8.5.2 线程同步

  1. 线程有自己的私有数据，比如栈和寄存器，同时与其它线程共享相同的虚拟内存和全局变量等资源。 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是当多个线程同时读写同一份共享资源的时候，会引起冲突，例如在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。这时候就需要引入线程同步机制使各个线程排队一个一个的对共享资源进行操作，而不是同时进行。

  2. 简单的说就是，在多线程编程里面，一些数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。

  3. 处理多线程问题时，多线程访问同一个对象，并且某些线程还想修改这个对象。这个时候我们就需要线程同步。

  4. 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成对列，等待前面线程使用完毕，下一个线程再使用。

  5. 由于同一进程的多个线程共享一块存储空间，在方便的同时，也带来了访问冲突，为了保证数据在方法中被访问时的正确性，再访问时加入锁机制，当一个线程获得对象的排他锁，多占资源，其他线程必须等待，使用后释放锁即可。

    • 会损失性能

    • 优先级倒置

  6. 线程不安全案例

     1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/22
 6  * JavaSE
 7  */
 8 public class UnsafeBuyTicket {
 9 ​
10     public static void main(String[] args) {
11         BuyTicket station = new BuyTicket();
12         new Thread(station,"小明").start();
13         new Thread(station,"黄牛").start();
14         new Thread(station,"老师").start();
15         new Thread(station,"教师").start();
16 ​
17     }
18 }
19 ​
20 class BuyTicket implements Runnable{
21 ​
22     //票
23     private int tikeNums = 10;
24     boolean flag = true;
25     @Override
26     public void run() {
27         //买票
28         while (flag){
29             try {
30                 buy();
31             } catch (InterruptedException e) {
32                 e.printStackTrace();
33             }
34         }
35 ​
36     }
37 ​
38     private void buy() throws InterruptedException {
39         //判断是否有票
40         if(tikeNums<=0){
41             flag = false;
42             return;
43         }
44         //模拟延时
45         Thread.sleep(100);
46 ​
47         //买票
48         System.out.println(Thread.currentThread().getName()+"拿到"+tikeNums--);
49     }
50 }
51 ​
52 ​
53 执行结果：
54 教师拿到10
55 小明拿到7
56 老师拿到8
57 黄牛拿到9
58 老师拿到6
59 黄牛拿到4
60 小明拿到5
61 教师拿到6
62 教师拿到2
63 老师拿到3
64 小明拿到1
65 黄牛拿到0
66 教师拿到-1
67 老师拿到-2

     

  7. 同步方法

    • 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是syncyhronized关键字，包括两种用法：同步方法、块

      img

  8. 同步的弊端：

    • 方法里面需要修改的内容才需要锁，锁太多，浪费资源

  9. 同步块

    • 同步块：syncyhronized（obj）{}

    • obj称为同步监视器

      • obj可以是任何对象，但是推荐使用共享资源作为同步监视器。

      • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

    • 同步监视器的执行过程

      • 第一个线程访问，锁定同步监视器，执行其中的代码

      • 第二个线程访问，发现同步监视器被锁定，无法访问

      • 第一个线程访问完毕，解锁同步监视器

      • 第二个线程访问完毕，发现同步监视器没有锁，然后锁定并访问。

8.5.3 队列和锁

1、队列

  • 队列是一个先进先出的抽象数据结构，可类比于生活中的排队场景。通常情况下，队列有数组和链表两种实现方式。

  • 采用链表实现的队列，没有个数限制。插入元素时直接接在链表的尾部，取出元素时直接从链表的头部取出即可。

  • 采用数组实现的队列，通常是循环数组，受限于数组的大小，存在天然的个数上限。插入和取出元素时，必须采用队列头部指针和队列尾部指针进行队列满和队列空的判断。

  • Java 定义了队列的基本操作，接口类型为 java.util.Queue，接口定义如下所示。Queue 定义了两套队列操作方法：

    • add、remove、element 操作失败抛出异常；

    • offer 操作失败返回 false 或抛出异常，poll、peek 操作失败返回 null；

2、锁

  • 同步操作的实现，需要给对象关联一个互斥体，这个互斥体就可以叫做锁。

  • 死锁

    • 线程之间相互等着对方释放资源，而自己的资源又不释放给别人，这种情况就是死锁。所以，只要其中一线程释放了资源，死锁就会被解除。

    • 实例

       1 package Demo032;
 2 ​
 3 /**
 4  * @Author: H-YONG-8
 5  * @DATA: 2023/4/22
 6  * JavaSE
 7  * 死锁
 8  */
 9 public class DeadLock {
10     public static void main(String[] args) {
11         Makeup g1 = new Makeup(0,"小明");
12         Makeup g2 = new Makeup(1,"小红");
13 ​
14         g1.start();
15         g2.start();
16 ​
17     }
18 }
19 ​
20 //口红
21 class Lipstick{
22 ​
23 }
24 ​
25 //镜子
26 class Mirror{
27 ​
28 }
29 class Makeup extends Thread{
30 ​
31     //需要的资源
32     static  Lipstick lipstick = new Lipstick();
33     static Mirror mirror = new Mirror();
34 ​
35     int chose;
36     String girlname;
37 ​
38     Makeup(int chose,String girlname){
39         this.chose = chose;
40         this.girlname = girlname;
41         }
42 ​
43 ​
44 ​
45 ​
46 ​
47     @Override
48     public void run() {
49         try {
50             makeup();
51         } catch (InterruptedException e) {
52             e.printStackTrace();
53         }
54     }
55 ​
56     //化妆
57     private void makeup() throws InterruptedException {
58         if (chose == 0) {
59             synchronized (lipstick){//获得口号的锁
60                 System.out.println(this.girlname+"获得口号的锁");
61                 Thread.sleep(1000);
62             }
63             synchronized (mirror){
64                 System.out.println(this.girlname+ "获得镜子的锁");
65             }
66         }else {
67             synchronized (mirror){//获得口号的锁
68                 System.out.println(this.girlname+"获得镜子的锁");
69                 Thread.sleep(2000);
70             }
71             synchronized (lipstick){
72                 System.out.println(this.girlname+ "获得口号的锁");
73             }
74         }
75     }
76 }
77 ​

       


      ​

    • 产生死锁的四个必要条件

      • 互斥条件：一个资源只能被一个进程使用

      • 请求与保持条件：一个进程因请求资源而阻塞时，对以获得的资源不放手

      • 不剥夺条件：进程以获得的资源，在未使用完前，不能强行剥夺

      • 循环等待条件：若干进程之间形成一个头尾相接的循环等待资源关系。

  • 重入锁

    • 重入锁指的是，一个线程在拥有了当前资源的锁之后，可以再次拿到该锁而不被阻塞。在后面会讲到synchronized的重入锁原理。

  • 自旋锁

    • 自旋锁指的是，线程在没有获得锁时，不是被直接挂起，而是执行一个空循环（自旋）。默认是循环10次。

    • 自旋锁的目的也就是为了减少线程被挂起的几率，因为线程的挂起和唤醒也都是耗资源的操作。

    • 如果锁被另一个线程占用的时间比较长，即使自旋了之后当前线程还是会被挂起，空循环就会变成浪费系统资源的操作，反而降低整体性能。所以，自旋锁是不适应锁占用时间长的并发情况的。

  • 自适应自旋锁

    • 自适应自旋锁是对自锁锁的一种优化。当一个线程自旋后成功获得了锁，那么下次自旋的次数就会增加。因为虚拟机认为，既然上次自旋期间成功拿到了锁，那么后面的自旋会有很大几率拿到锁。相反，如果对于某个锁，很少有自旋能够成功获得的，那么后面就会减少自旋次数，甚至省略掉自旋过程，以免浪费处理器资源。这种锁是默认开启的。

  • 锁消除

    • 锁消除指的是，在编译期间利用“逃逸分析技术”分析出那些不存在竞争却加了锁的代码的锁失效。这样就减少了锁的请求与释放操作，因为锁的请求与释放都会消耗系统资源。

3、两者关系

  • 队列和锁在一起解决线程安全性

8.5.4 Lock(锁)

  • 显示加锁，可以知道位置

img

在这里插入图片描述

  • 代码实例：

     1 package dead;
 2 ​
 3 import java.util.concurrent.locks.ReentrantLock;
 4 ​
 5 public class TestLock {
 6     public static void main(String[] args) {
 7         TestLock2 testLock2=new TestLock2();
 8         new Thread(testLock2).start();
 9         new Thread(testLock2).start();
10         new Thread(testLock2).start();
11 ​
12     }
13 }
14 //定义Lock
15 ​
16 //买票的线程
17 class TestLock2 implements Runnable{
18     //定义Lock
19     private final ReentrantLock lock= new ReentrantLock();
20     int num=10;
21     @Override
22     public void run() {
23         while (true){
24             try {
25                 lock.lock();
26                 if (num>0){
27                     try {
28                         Thread.sleep(1000);
29                     } catch (InterruptedException e) {
30                         e.printStackTrace();
31                     }
32                     System.out.println(num--);
33                 }
34                 else {
35                     break;
36                 }
37 ​
38             } finally {
39                 lock.unlock();
40             }
41 ​
42 ​
43         }
44 ​
45     }
46 }

     


    ​

     

 

 

8.6 线程通信问题

在这里插入图片描述

 

在这里插入图片描述

img

img

img

  • 实例

      1 /**
  2  * 测试:生产者消费者模型-->利用缓冲区解决:管程法
  3  */
  4 public class Demo33_ThreadPC {
  5     public static void main(String[] args) {
  6         SynContainer synContainer = new SynContainer();
  7         new Producer(synContainer).start();
  8         new Consumer(synContainer).start();
  9     }
 10 }
 11 ​
 12 //生产者
 13 class Producer extends Thread {
 14     //容缓冲区
 15     SynContainer container;
 16 ​
 17     public Producer(SynContainer container) {
 18         this.container = container;
 19     }
 20 ​
 21     //生产
 22     @Override
 23     public void run() {
 24         for (int i = 0; i < 100; i++) {
 25             container.push(new Product(i));
 26             System.out.println("生产了" + i + "件产品");
 27         }
 28     }
 29 }
 30 ​
 31 //消费者
 32 class Consumer extends Thread {
 33     //容缓冲区
 34     SynContainer container;
 35 ​
 36     public Consumer(SynContainer container) {
 37         this.container = container;
 38     }
 39 ​
 40     //消费
 41     @Override
 42     public void run() {
 43         for (int i = 0; i < 100; i++) {
 44             System.out.println("消费了-->" + container.pop().id + "件产品");
 45         }
 46     }
 47 }
 48 ​
 49 //产品
 50 class Product {
 51     int id;//产品编号
 52 ​
 53     public Product(int id) {
 54         this.id = id;
 55     }
 56 }
 57 ​
 58 //缓冲区
 59 class SynContainer {
 60     //需要一个容器大小
 61     Product[] products = new Product[10];
 62     //容器计数器
 63     int count = 0;
 64 ​
 65     //生产者放入产品
 66     public synchronized void push(Product product) {
 67         //如果容器满了,需要等待消费者消费
 68         /*如果是if的话，假如消费者1消费了最后一个，这是index变成0此时释放锁被消费者2拿到而不是生产者拿到，这时消费者的wait是在if里所以它就直接去消费index-1下标越界，如果是while就会再去判断一下index得值是不是变成0了*/
 69         while (count == products.length) {
 70             //通知消费者消费,等待生产
 71             try {
 72                 this.wait();
 73             } catch (InterruptedException e) {
 74                 e.printStackTrace();
 75             }
 76         }
 77         //如果没有满,需要丢入产品
 78         products[count] = product;
 79         count++;
 80         //通知消费者消费
 81         this.notifyAll();
 82     }
 83 ​
 84     //消费者消费产品
 85     public synchronized Product pop() {
 86         //判断是否能消费
 87         while (count <= 0) {
 88             //等待生产者生产
 89             try {
 90                 this.wait();
 91             } catch (InterruptedException e) {
 92                 e.printStackTrace();
 93             }
 94         }
 95         //如果可以消费
 96         count--;
 97         Product product = products[count];
 98         //吃完了 通知生产者生产
 99         this.notifyAll();
100         return product;
101     }
102 }
103 ​

     

     

8.7 线程池

在这里插入图片描述

 1 //测试线程池
 2 public class Demo35_ThreadPool {
 3     public static void main(String[] args) {
 4         // 1. 创建服务,擦行间线程池
 5         // newFixedThreadPool(线程池大小)
 6         ExecutorService service = Executors.newFixedThreadPool(10);
 7         //执行
 8         service.execute(new MyThread());
 9         service.execute(new MyThread());
10         service.execute(new MyThread());
11         service.execute(new MyThread());
12         service.execute(new MyThread());
13         service.execute(new MyThread());
14         //关闭连接
15         service.shutdown();
16     }
17 }
18 ​
19 class MyThread implements Runnable {
20     @Override
21     public void run() {
22         System.out.println(Thread.currentThread().getName());
23     }
24 }

 


​
posted @ 2023-04-22 20:48  H-YONG-8  阅读(132)  评论(0)  编辑  收藏  举报