1.基本概念：程序，进程，线程

1.程序

程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

2.进程

进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

  • 如：运行中的QQ，运行中的MP3播放器
  • 程序是静态的，进程是动态的

  • 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

    3.线程

    线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

  • 若一个进程同一时间并行执行多个线程，就是支持多线程的

  • 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
  • 一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

image.png

4.单核CPU和多核CPU的理解

  • 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
  • 如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
  • 一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

    5.并行与并发

    并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
    并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

    6.多线程的优点

    背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：
1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2. 提高计算机系统CPU的利用率
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

7.需要使用多线程的场景

  • 程序需要同时执行两个或多个任务。
  • 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

  • 需要一些后台运行的程序时。

    2.线程的创建与使用

    1.线程的创建与启动

  • Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。

  • Thread类的特性
    • 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
    • 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()

2.API创建线程的两种方式

1.继承于Thread类

1.步骤

1.创建一个继承于Thread类的子类
2.重写Thread类的run（）——>将此线程执行的操作声明在run（）中；
3.创建Thread类的子类的对象；
4.通过过此对象调用start（）：①启动当前线程；②调用当前线程的run（）

  1. package Thread;
  3. /**
  4.  * @Author 戴尔
  5.  * @Date 2021/12/21 9:16
  6.  * @Version 1.0
  7.  */
  8. class MyThread extends Thread {
  10.     @Override
  11.     public void run() {
  12.         for (int i = 0; i < 20; i++) {
  13.             if (i%2==0){
  14.                 System.out.println(Thread.currentThread().getName() +">>>" + i);
  15.             }
  17.         }
  18.     }
  19. }
  21. public class ThreadTest{
  22.     public static void main(String[] args) {
  23.         MyThread t1 = new MyThread("t1");
  24.         MyThread t2 = new MyThread("t2");
  25.         MyThread t3 = new MyThread("t3");
  26.         t1.start();
  27.         t2.start();
  28.        t3.start();
  29.     }
  30. }

运行结果

  1. Thread-0>>>0
  2. Thread-1>>>0
  3. Thread-2>>>0
  4. Thread-1>>>2
  5. Thread-0>>>2
  6. Thread-1>>>4
  7. Thread-2>>>2
  8. Thread-1>>>6
  9. Thread-0>>>4
  10. Thread-1>>>8
  11. Thread-2>>>4
  12. Thread-1>>>10
  13. Thread-0>>>6
  14. Thread-1>>>12
  15. Thread-2>>>6
  16. Thread-1>>>14
  17. Thread-0>>>8
  18. Thread-1>>>16
  19. Thread-2>>>8
  20. Thread-1>>>18
  21. Thread-0>>>10
  22. Thread-2>>>10
  23. Thread-0>>>12
  24. Thread-2>>>12
  25. Thread-0>>>14
  26. Thread-2>>>14
  27. Thread-0>>>16
  28. Thread-2>>>16
  29. Thread-0>>>18
  30. Thread-2>>>18

image.png

2.使用注意

  1. 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
    2. run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
    3. 想要启动多线程，必须调用start方法。
    4. 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。

    3.另一种实现方法

    若该线程仅使用一次，可使用创建Thread类的匿名子类创建线程
    1. new Thread(){
    2.          @Override
    3.          public void run() {
    4.              for (int i = 0; i <100 ; i++) {
    5.                  if (i%2==0){
    6.                      System.out.println(Thread.currentThread().getName()+">>"+i);
    7.                  }
    8.              }
    9.          }
    10.      }.start();

    2.实现Runnable接口

    1.实现步骤

    1) 定义子类，实现Runnable接口。
    2) 子类中重写Runnable接口中的run方法。
    3) 通过Thread类含参构造器创建线程对象。
    4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
    5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。 ```java package Thread;

/**

  • @Author 戴尔
  • @Date 2021/12/25 17:29
  • @Version 1.0 */

//1.创建一个实现了Runnable接口的类 class MThread implements Runnable{

  1. //2.实现类去实现Runnable中的抽象方法：run（）
  2. @Override
  3. public void run() {
  4.     for (int i = 0; i <100 ; i++) {
  5.         if (i%2==0){
  6.             System.out.println(Thread.currentThread().getName()+">>"+i);
  7.         }
  8.     }
  9. }

}

public class ThreadTest1 { public static void main(String[] args) { //3.创建实现类的对象 MThread m1=new MThread(); //4.将此对象作为参数传递到Thread类的构造器中，创建Thread的对象 Thread t1=new Thread(m1); t1.setName(“线程一”); //5.通过Thread类的对象调用start（）; t1.start();

  1.     Thread t2=new Thread(m1);
  2.     t2.setName("主线程！");
  3.     t2.start();
  4.     System.out.println(Thread.currentThread().getName());
  5. }

}

  1. **执行结果**
  2. ```java
  3. C:\Users\戴尔\.jdks\openjdk-15.0.1-1\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\lib\idea_rt.jar=58734:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\bin" -Dfile.encoding=UTF-8 -classpath C:\Users\戴尔\IdeaProjects\untitled\out\production\JavaSE Thread.ThreadTest1
  4. main
  5. 线程一>>0
  6. 主线程！>>0
  7. 线程一>>2
  8. 线程一>>4
  9. 主线程！>>2
  10. 线程一>>6
  11. 线程一>>8
  12. 主线程！>>4
  13. 线程一>>10
  14. 主线程！>>6
  15. 线程一>>12
  16. 线程一>>14
  17. 线程一>>16
  18. 主线程！>>8
  19. 线程一>>18
  20. 主线程！>>10
  21. 线程一>>20
  22. 线程一>>22
  23. 线程一>>24
  24. 主线程！>>12
  25. 线程一>>26
  26. 线程一>>28
  27. 线程一>>30
  28. 主线程！>>14
  29. 线程一>>32
  30. 主线程！>>16
  31. 线程一>>34
  32. 线程一>>36
  33. 线程一>>38
  34. 主线程！>>18
  35. 线程一>>40
  36. 主线程！>>20
  37. 线程一>>42
  38. 线程一>>44
  39. 线程一>>46
  40. 主线程！>>22
  41. 线程一>>48
  42. 主线程！>>24
  43. 线程一>>50
  44. 主线程！>>26
  45. 线程一>>52
  46. 线程一>>54
  47. 线程一>>56
  48. 主线程！>>28
  49. 线程一>>58
  50. 主线程！>>30
  51. 线程一>>60
  52. 线程一>>62
  53. 主线程！>>32
  54. 线程一>>64
  55. 主线程！>>34
  56. 线程一>>66
  57. 线程一>>68
  58. 线程一>>70
  59. 线程一>>72
  60. 线程一>>74
  61. 主线程！>>36
  62. 线程一>>76
  63. 主线程！>>38
  64. 线程一>>78
  65. 主线程！>>40
  66. 线程一>>80
  67. 主线程！>>42
  68. 线程一>>82
  69. 线程一>>84
  70. 线程一>>86
  71. 主线程！>>44
  72. 线程一>>88
  73. 线程一>>90
  74. 线程一>>92
  75. 线程一>>94
  76. 线程一>>96
  77. 主线程！>>46
  78. 线程一>>98
  79. 主线程！>>48
  80. 主线程！>>50
  81. 主线程！>>52
  82. 主线程！>>54
  83. 主线程！>>56
  84. 主线程！>>58
  85. 主线程！>>60
  86. 主线程！>>62
  87. 主线程！>>64
  88. 主线程！>>66
  89. 主线程！>>68
  90. 主线程！>>70
  91. 主线程！>>72
  92. 主线程！>>74
  93. 主线程！>>76
  94. 主线程！>>78
  95. 主线程！>>80
  96. 主线程！>>82
  97. 主线程！>>84
  98. 主线程！>>86
  99. 主线程！>>88
  100. 主线程！>>90
  101. 主线程！>>92
  102. 主线程！>>94
  103. 主线程！>>96
  104. 主线程！>>98
  106. Process finished with exit code 0

3.继承方式和实现方式的联系与区别

  • 比较创建线程的两种方式。
  • 开发中:优先选择:实现Runnable接口的方式
  • 原因:
  • 1.实现的方式没有类的单继承性的局限性
  • 2.实现的方式更适合来处理多个线程有共享数据的情况。
  • 联系: public class Thread implements Runnable
  • 相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。

    4.线程的分类

    Java中的线程分为两类：一种是守护线程，一种是用户线程。
     它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
     守护线程是用来服务用户线程的，通过在start()方法前调用
    thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
     Java垃圾回收就是一个典型的守护线程。
     若JVM中都是守护线程，当前JVM将退出。
     形象理解：兔（用户线程）死狗（守护线程）烹，鸟尽弓藏
    一个Java应用程序java.exe，其实至少有三个线程：main()主线程（）（用户线程），gc()垃圾回收线程（守护线程），异常处理线程。当然如果发生异常，会影响主线程。

3.Thread相关方法

void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称 

  1. public HelloThread(String name){
  2.         super(name);
  3. }
  5. HelloThread h1=new HelloThread（Thread：1）

static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类
static void yield()：线程让步 （释放当前CPU的执行权）

  • 暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
  • 若队列中没有同优先级的线程，忽略此方法

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止

  • 低优先级的线程也可以获得执行

    在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。

yield：争球（本轮礼让后，再公平竞争）；join：球权转换（强行插队）
static void sleep(long millis)：(指定时间:毫秒)

  • 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
  • 抛出InterruptedException异常

stop(): 强制线程生命期结束，不推荐使用
boolean isAlive()：返回boolean，判断线程是否还活着。

  1. package Thread;
  3. /**
  4.  * @Author 戴尔
  5.  * @Date 2021/12/21 11:15
  6.  * @Version 1.0
  7.  */
  8. class HelloThread extends Thread{
  9.     @Override
  10.     public void run() {
  11.         for (int i = 0; i <100 ; i++) {
  12.             if (i%2==0){
  13.                 try {
  14.                     sleep(1000);
  15.                 } catch (InterruptedException e) {
  16.                     e.printStackTrace();
  17.                 }
  18.                 System.out.println(Thread.currentThread().getName()+":"+i);
  19.             }
  20.         }
  22.     }
  23. public HelloThread(String name){
  24.         super(name);
  25.     }
  26. }
  29. public class ThreadMethodTest {
  30.     public static void main(String[] args) {
  31.         HelloThread h1=new HelloThread("Thread:1");
  32.         h1.setName("线程一！");
  33.         h1.start();
  35.         Thread.currentThread().setName("主线程");
  37.         for (int i = 0; i <100 ; i++) {
  38.             if (i%2==0){
  39.                 System.out.println(Thread.currentThread().getName()+":"+i);
  40.             }
  41.             if (i%20==0){
  42.                 Thread.yield();
  43.             }
  44.             if (i==20){
  45.                 try {
  46.                     h1.join();
  47.                 } catch (InterruptedException e) {
  48.                     e.printStackTrace();
  49.                 }
  50.             }
  51.         }
  52.     }
  53. }

4.线程优先级的设置

1.线程的调度

1.调度策略

时间片
image.png
抢占式：高优先级的线程抢占CPU

2.Java的调度方法

同优先级线程组成先进先出队列（先到先服务），使用时间片策略
对高优先级，使用优先调度的抢占式策略

2.线程的优先级

1.线程的优先等级

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5

2.涉及的方法

getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级

3.说明

线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

  1. package Thread;
  3. /**
  4.  * @Author 戴尔
  5.  * @Date 2021/12/25 15:10
  6.  * @Version 1.0
  7.  */
  8. class ThreadPriorityTest extends Thread{
  9.     @Override
  10.     public void run() {
  11.         for (int i = 0; i <100 ; i++) {
  12.             if (i%2==0){
  13.                 System.out.println(Thread.currentThread().getName()+">>"+i);
  14.             }
  15.         }
  16.     }
  17. }
  19. public class ThreadPriority {
  20.     public static void main(String[] args) {
  21.         ThreadPriorityTest p1=new ThreadPriorityTest();
  22.         p1.setName("线程一");
  23.         p1.start();
  24.         p1.setPriority(Thread.MAX_PRIORITY);
  25.         for (int i = 0; i <100; i++) {
  26.             if (i%5==0){
  27.                 Thread.currentThread().setName("主线程");
  28.                 Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
  29.                 System.out.println(Thread.currentThread().getName()+">>"+i);
  30.             }
  31.         }
  32.     }
  34. }

执行结果

  1. C:\Users\戴尔\.jdks\openjdk-15.0.1-1\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\lib\idea_rt.jar=61331:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\bin" -Dfile.encoding=UTF-8 -classpath C:\Users\戴尔\IdeaProjects\untitled\out\production\JavaSE Thread.ThreadPriority
  2. 线程一>>0
  3. 线程一>>2
  4. 线程一>>4
  5. 线程一>>6
  6. 主线程>>0
  7. 线程一>>8
  8. 线程一>>10
  9. 线程一>>12
  10. 主线程>>5
  11. 线程一>>14
  12. 线程一>>16
  13. 线程一>>18
  14. 主线程>>10
  15. 线程一>>20
  16. 线程一>>22
  17. 线程一>>24
  18. 线程一>>26
  19. 线程一>>28
  20. 线程一>>30
  21. 主线程>>15
  22. 线程一>>32
  23. 线程一>>34
  24. 线程一>>36
  25. 主线程>>20
  26. 线程一>>38
  27. 线程一>>40
  28. 线程一>>42
  29. 线程一>>44
  30. 线程一>>46
  31. 线程一>>48
  32. 线程一>>50
  33. 线程一>>52
  34. 线程一>>54
  35. 线程一>>56
  36. 线程一>>58
  37. 线程一>>60
  38. 线程一>>62
  39. 线程一>>64
  40. 线程一>>66
  41. 线程一>>68
  42. 线程一>>70
  43. 线程一>>72
  44. 线程一>>74
  45. 线程一>>76
  46. 线程一>>78
  47. 主线程>>25
  48. 主线程>>30
  49. 线程一>>80
  50. 线程一>>82
  51. 主线程>>35
  52. 线程一>>84
  53. 主线程>>40
  54. 线程一>>86
  55. 主线程>>45
  56. 线程一>>88
  57. 主线程>>50
  58. 线程一>>90
  59. 主线程>>55
  60. 线程一>>92
  61. 主线程>>60
  62. 线程一>>94
  63. 主线程>>65
  64. 线程一>>96
  65. 主线程>>70
  66. 线程一>>98
  67. 主线程>>75
  68. 主线程>>80
  69. 主线程>>85
  70. 主线程>>90
  71. 主线程>>95
  73. Process finished with exit code 0

5.多窗口卖票Demo——多线程的应用

1.继承于Thread类方式实现

  1. package Thread;
  2. /**
  3.  * @Author 戴尔
  4.  * @Date 2021/12/25 15:29
  5.  * @Version 1.0
  6.  */
  7. class Window extends Thread{
  8.     private static int ticket = 100;
  10.     @Override
  11.     public void run() {
  12.         while (true){
  13.             if (ticket>0){
  14.                 System.out.println(getName()+":卖票，票号为："+ticket);
  15.                 ticket--;
  16.             }else{
  17.                 break;
  18.             }
  19.         }
  20.     }
  21. }
  22. public class ThreadDemo2 {
  23.     public static void main(String[] args) {
  24.         Window w1=new Window();
  25.         Window w2=new Window();
  26.         Window w3=new Window();
  28.         w1.setName("窗口一");
  29.         w2.setName("窗口二");
  30.         w3.setName("窗口三");
  32.         w1.start();
  33.         w2.start();
  34.         w3.start();
  35.     }
  36. }

执行结果

  1. C:\Users\戴尔\.jdks\openjdk-15.0.1-1\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\lib\idea_rt.jar=65300:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\bin" -Dfile.encoding=UTF-8 -classpath C:\Users\戴尔\IdeaProjects\untitled\out\production\JavaSE Thread.ThreadDemo2
  2. 窗口三:卖票，票号为：100
  3. 窗口二:卖票，票号为：100
  4. 窗口一:卖票，票号为：100
  5. 窗口二:卖票，票号为：98
  6. 窗口三:卖票，票号为：99
  7. 窗口二:卖票，票号为：96
  8. 窗口二:卖票，票号为：94
  9. 窗口一:卖票，票号为：97
  10. 窗口二:卖票，票号为：93
  11. 窗口三:卖票，票号为：95
  12. 窗口二:卖票，票号为：91
  13. 窗口一:卖票，票号为：92
  14. 窗口二:卖票，票号为：89
  15. 窗口三:卖票，票号为：90
  16. 窗口二:卖票，票号为：87
  17. 窗口一:卖票，票号为：88
  18. 窗口二:卖票，票号为：85
  19. 窗口二:卖票，票号为：83
  20. 窗口二:卖票，票号为：82
  21. 窗口三:卖票，票号为：86
  22. 窗口二:卖票，票号为：81
  23. 窗口一:卖票，票号为：84
  24. 窗口二:卖票，票号为：79
  25. 窗口三:卖票，票号为：80
  26. 窗口二:卖票，票号为：77
  27. 窗口一:卖票，票号为：78
  28. 窗口二:卖票，票号为：75
  29. 窗口三:卖票，票号为：76
  30. 窗口二:卖票，票号为：73
  31. 窗口一:卖票，票号为：74
  32. 窗口二:卖票，票号为：71
  33. 窗口三:卖票，票号为：72
  34. 窗口二:卖票，票号为：69
  35. 窗口一:卖票，票号为：70
  36. 窗口二:卖票，票号为：67
  37. 窗口三:卖票，票号为：68
  38. 窗口二:卖票，票号为：65
  39. 窗口二:卖票，票号为：63
  40. 窗口二:卖票，票号为：62
  41. 窗口一:卖票，票号为：66
  42. 窗口二:卖票，票号为：61
  43. 窗口三:卖票，票号为：64
  44. 窗口二:卖票，票号为：59
  45. 窗口一:卖票，票号为：60
  46. 窗口一:卖票，票号为：56
  47. 窗口一:卖票，票号为：55
  48. 窗口一:卖票，票号为：54
  49. 窗口一:卖票，票号为：53
  50. 窗口一:卖票，票号为：52
  51. 窗口一:卖票，票号为：51
  52. 窗口一:卖票，票号为：50
  53. 窗口一:卖票，票号为：49
  54. 窗口一:卖票，票号为：48
  55. 窗口一:卖票，票号为：47
  56. 窗口一:卖票，票号为：46
  57. 窗口二:卖票，票号为：57
  58. 窗口一:卖票，票号为：45
  59. 窗口一:卖票，票号为：43
  60. 窗口三:卖票，票号为：58
  61. 窗口一:卖票，票号为：42
  62. 窗口二:卖票，票号为：44
  63. 窗口一:卖票，票号为：40
  64. 窗口三:卖票，票号为：41
  65. 窗口一:卖票，票号为：38
  66. 窗口二:卖票，票号为：39
  67. 窗口一:卖票，票号为：36
  68. 窗口三:卖票，票号为：37
  69. 窗口一:卖票，票号为：34
  70. 窗口二:卖票，票号为：35
  71. 窗口一:卖票，票号为：32
  72. 窗口三:卖票，票号为：33
  73. 窗口一:卖票，票号为：30
  74. 窗口二:卖票，票号为：31
  75. 窗口二:卖票，票号为：27
  76. 窗口一:卖票，票号为：28
  77. 窗口三:卖票，票号为：29
  78. 窗口一:卖票，票号为：25
  79. 窗口二:卖票，票号为：26
  80. 窗口一:卖票，票号为：23
  81. 窗口三:卖票，票号为：24
  82. 窗口一:卖票，票号为：21
  83. 窗口二:卖票，票号为：22
  84. 窗口一:卖票，票号为：19
  85. 窗口三:卖票，票号为：20
  86. 窗口一:卖票，票号为：17
  87. 窗口二:卖票，票号为：18
  88. 窗口二:卖票，票号为：14
  89. 窗口一:卖票，票号为：15
  90. 窗口三:卖票，票号为：16
  91. 窗口一:卖票，票号为：12
  92. 窗口一:卖票，票号为：10
  93. 窗口二:卖票，票号为：13
  94. 窗口一:卖票，票号为：9
  95. 窗口一:卖票，票号为：7
  96. 窗口三:卖票，票号为：11
  97. 窗口一:卖票，票号为：6
  98. 窗口一:卖票，票号为：4
  99. 窗口一:卖票，票号为：3
  100. 窗口一:卖票，票号为：2
  101. 窗口一:卖票，票号为：1
  102. 窗口二:卖票，票号为：8
  103. 窗口三:卖票，票号为：5
  105. Process finished with exit code 0

2.实现Runnable接口方式实现

  1. package Thread;
  3. /**
  4.  * @Author 戴尔
  5.  * @Date 2021/12/26 23:34
  6.  * @Version 1.0
  7.  */
  8. class window1 implements Runnable{
  9.     private int ticket=100;
  11.     @Override
  12.     public void run() {
  13.         while (true){
  14.             if (ticket>0){
  15.                 System.out.println(Thread.currentThread().getName()+":卖票：票号为："+ticket);
  16.                 ticket--;
  17.             }
  18.             else {
  19.                 break;
  20.             }
  21.         }
  22.     }
  23. }
  25. public class ThreadDemo3 {
  26.     public static void main(String[] args) {
  27.         window1 w=new window1();
  29.         Thread t1 = new Thread(w);
  30.         Thread t2 = new Thread(w);
  31.         Thread t3 = new Thread(w);
  33.         t1.setName("窗口1");
  34.         t2.setName("窗口2");
  35.         t3.setName("窗口3");
  37.         t1.start();
  38.         t2.start();
  39.         t3.start();
  40.     }
  41. }

执行结果

  1. C:\Users\戴尔\.jdks\openjdk-15.0.1-1\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\lib\idea_rt.jar=52285:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\bin" -Dfile.encoding=UTF-8 -classpath C:\Users\戴尔\IdeaProjects\untitled\out\production\JavaSE Thread.ThreadDemo3
  2. 窗口2:卖票：票号为：100
  3. 窗口1:卖票：票号为：100
  4. 窗口1:卖票：票号为：98
  5. 窗口1:卖票：票号为：97
  6. 窗口3:卖票：票号为：100
  7. 窗口1:卖票：票号为：96
  8. 窗口1:卖票：票号为：94
  9. 窗口2:卖票：票号为：99
  10. 窗口1:卖票：票号为：93
  11. 窗口1:卖票：票号为：91
  12. 窗口3:卖票：票号为：95
  13. 窗口1:卖票：票号为：90
  14. 窗口2:卖票：票号为：92
  15. 窗口1:卖票：票号为：88
  16. 窗口1:卖票：票号为：86
  17. 窗口3:卖票：票号为：89
  18. 窗口1:卖票：票号为：85
  19. 窗口1:卖票：票号为：83
  20. 窗口2:卖票：票号为：87
  21. 窗口1:卖票：票号为：82
  22. 窗口1:卖票：票号为：80
  23. 窗口3:卖票：票号为：84
  24. 窗口1:卖票：票号为：79
  25. 窗口2:卖票：票号为：81
  26. 窗口2:卖票：票号为：76
  27. 窗口1:卖票：票号为：77
  28. 窗口3:卖票：票号为：78
  29. 窗口3:卖票：票号为：73
  30. 窗口1:卖票：票号为：74
  31. 窗口1:卖票：票号为：71
  32. 窗口2:卖票：票号为：75
  33. 窗口2:卖票：票号为：69
  34. 窗口1:卖票：票号为：70
  35. 窗口3:卖票：票号为：72
  36. 窗口1:卖票：票号为：67
  37. 窗口1:卖票：票号为：65
  38. 窗口2:卖票：票号为：68
  39. 窗口1:卖票：票号为：64
  40. 窗口3:卖票：票号为：66
  41. 窗口1:卖票：票号为：62
  42. 窗口2:卖票：票号为：63
  43. 窗口1:卖票：票号为：60
  44. 窗口1:卖票：票号为：58
  45. 窗口3:卖票：票号为：61
  46. 窗口1:卖票：票号为：57
  47. 窗口2:卖票：票号为：59
  48. 窗口1:卖票：票号为：55
  49. 窗口1:卖票：票号为：53
  50. 窗口3:卖票：票号为：56
  51. 窗口1:卖票：票号为：52
  52. 窗口2:卖票：票号为：54
  53. 窗口1:卖票：票号为：50
  54. 窗口3:卖票：票号为：51
  55. 窗口1:卖票：票号为：48
  56. 窗口2:卖票：票号为：49
  57. 窗口3:卖票：票号为：47
  58. 窗口1:卖票：票号为：46
  59. 窗口3:卖票：票号为：44
  60. 窗口2:卖票：票号为：45
  61. 窗口3:卖票：票号为：42
  62. 窗口1:卖票：票号为：43
  63. 窗口3:卖票：票号为：40
  64. 窗口2:卖票：票号为：41
  65. 窗口3:卖票：票号为：38
  66. 窗口1:卖票：票号为：39
  67. 窗口3:卖票：票号为：36
  68. 窗口2:卖票：票号为：37
  69. 窗口3:卖票：票号为：34
  70. 窗口1:卖票：票号为：35
  71. 窗口1:卖票：票号为：31
  72. 窗口3:卖票：票号为：32
  73. 窗口2:卖票：票号为：33
  74. 窗口3:卖票：票号为：29
  75. 窗口3:卖票：票号为：27
  76. 窗口3:卖票：票号为：26
  77. 窗口1:卖票：票号为：30
  78. 窗口3:卖票：票号为：25
  79. 窗口3:卖票：票号为：23
  80. 窗口2:卖票：票号为：28
  81. 窗口3:卖票：票号为：22
  82. 窗口1:卖票：票号为：24
  83. 窗口3:卖票：票号为：20
  84. 窗口2:卖票：票号为：21
  85. 窗口3:卖票：票号为：18
  86. 窗口1:卖票：票号为：19
  87. 窗口1:卖票：票号为：15
  88. 窗口1:卖票：票号为：14
  89. 窗口1:卖票：票号为：13
  90. 窗口3:卖票：票号为：16
  91. 窗口2:卖票：票号为：17
  92. 窗口3:卖票：票号为：11
  93. 窗口1:卖票：票号为：12
  94. 窗口3:卖票：票号为：9
  95. 窗口2:卖票：票号为：10
  96. 窗口3:卖票：票号为：7
  97. 窗口1:卖票：票号为：8
  98. 窗口3:卖票：票号为：5
  99. 窗口3:卖票：票号为：3
  100. 窗口2:卖票：票号为：6
  101. 窗口2:卖票：票号为：1
  102. 窗口3:卖票：票号为：2
  103. 窗口1:卖票：票号为：4
  104. Process finished with exit code 0

3.线程的生命周期

1.线程的状态

JDK中用Thread.State类定义了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

  • 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
  • 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
  • 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
  • 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
  • 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

image.png

4.线程的同步

1.问题的提出

  • 多个线程执行的不确定性引起执行结果的不稳定
  • 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

image.png

2.例题引入

1.题目描述

模拟火车站售票程序，开启三个窗口售票。

2.例题代码

  1. package Thread;
  3. /**
  4.  * @Author 戴尔
  5.  * @Date 2021/12/26 23:34
  6.  * @Version 1.0
  7.  */
  8. class window1 implements Runnable{
  9.     private int ticket=100;
  11.     @Override
  12.     public void run() {
  13.         while (true){
  14.             if (ticket>0){
  16.                 try {
  17.                     Thread.sleep(100);
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  22.                 System.out.println(Thread.currentThread().getName()+":卖票：票号为："+ticket);
  23.                 ticket--;
  24.             }
  25.             else {
  26.                 break;
  27.             }
  28.         }
  29.     }
  30. }
  32. public class ThreadDemo3 {
  33.     public static void main(String[] args) {
  34.         window1 w=new window1();
  36.         Thread t1 = new Thread(w);
  37.         Thread t2 = new Thread(w);
  38.         Thread t3 = new Thread(w);
  40.         t1.setName("窗口1");
  41.         t2.setName("窗口2");
  42.         t3.setName("窗口3");
  44.         t1.start();
  45.         t2.start();
  46.         t3.start();
  47.     }
  48. }

执行结果

  1. C:\Users\戴尔\.jdks\openjdk-15.0.1-1\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\lib\idea_rt.jar=62966:C:\Program Files\JetBrains\IntelliJ IDEA 2020.1.1.1\bin" -Dfile.encoding=UTF-8 -classpath C:\Users\戴尔\IdeaProjects\untitled\out\production\JavaSE Thread.ThreadDemo3
  2. 窗口2:卖票：票号为：100
  3. 窗口3:卖票：票号为：100
  4. 窗口1:卖票：票号为：100
  5. 窗口3:卖票：票号为：97
  6. 窗口2:卖票：票号为：97
  7. 窗口1:卖票：票号为：95
  8. 窗口3:卖票：票号为：94
  9. 窗口2:卖票：票号为：93
  10. 窗口1:卖票：票号为：92
  11. 窗口3:卖票：票号为：91
  12. 窗口2:卖票：票号为：91
  13. 窗口1:卖票：票号为：89
  14. 窗口3:卖票：票号为：88
  15. 窗口2:卖票：票号为：87
  16. 窗口1:卖票：票号为：86
  17. 窗口3:卖票：票号为：85
  18. 窗口2:卖票：票号为：84
  19. 窗口1:卖票：票号为：83
  20. 窗口3:卖票：票号为：82
  21. 窗口2:卖票：票号为：81
  22. 窗口1:卖票：票号为：80
  23. 窗口3:卖票：票号为：79
  24. 窗口2:卖票：票号为：78
  25. 窗口1:卖票：票号为：77
  26. 窗口3:卖票：票号为：76
  27. 窗口2:卖票：票号为：75
  28. 窗口1:卖票：票号为：74
  29. 窗口3:卖票：票号为：73
  30. 窗口2:卖票：票号为：72
  31. 窗口1:卖票：票号为：71
  32. 窗口3:卖票：票号为：70
  33. 窗口2:卖票：票号为：69
  34. 窗口1:卖票：票号为：68
  35. 窗口3:卖票：票号为：67
  36. 窗口2:卖票：票号为：66
  37. 窗口1:卖票：票号为：65
  38. 窗口3:卖票：票号为：64
  39. 窗口2:卖票：票号为：63
  40. 窗口1:卖票：票号为：62
  41. 窗口3:卖票：票号为：61
  42. 窗口2:卖票：票号为：60
  43. 窗口1:卖票：票号为：59
  44. 窗口3:卖票：票号为：58
  45. 窗口2:卖票：票号为：57
  46. 窗口1:卖票：票号为：56
  47. 窗口3:卖票：票号为：55
  48. 窗口2:卖票：票号为：54
  49. 窗口1:卖票：票号为：53
  50. 窗口3:卖票：票号为：52
  51. 窗口2:卖票：票号为：51
  52. 窗口1:卖票：票号为：50
  53. 窗口3:卖票：票号为：49
  54. 窗口2:卖票：票号为：48
  55. 窗口1:卖票：票号为：47
  56. 窗口3:卖票：票号为：46
  57. 窗口2:卖票：票号为：45
  58. 窗口1:卖票：票号为：44
  59. 窗口3:卖票：票号为：43
  60. 窗口2:卖票：票号为：42
  61. 窗口1:卖票：票号为：41
  62. 窗口3:卖票：票号为：40
  63. 窗口2:卖票：票号为：39
  64. 窗口1:卖票：票号为：38
  65. 窗口3:卖票：票号为：37
  66. 窗口2:卖票：票号为：36
  67. 窗口1:卖票：票号为：35
  68. 窗口3:卖票：票号为：34
  69. 窗口2:卖票：票号为：33
  70. 窗口1:卖票：票号为：32
  71. 窗口3:卖票：票号为：31
  72. 窗口2:卖票：票号为：30
  73. 窗口1:卖票：票号为：29
  74. 窗口3:卖票：票号为：28
  75. 窗口2:卖票：票号为：27
  76. 窗口1:卖票：票号为：26
  77. 窗口3:卖票：票号为：25
  78. 窗口2:卖票：票号为：24
  79. 窗口1:卖票：票号为：23
  80. 窗口3:卖票：票号为：22
  81. 窗口2:卖票：票号为：21
  82. 窗口1:卖票：票号为：20
  83. 窗口3:卖票：票号为：19
  84. 窗口2:卖票：票号为：18
  85. 窗口1:卖票：票号为：17
  86. 窗口3:卖票：票号为：16
  87. 窗口2:卖票：票号为：15
  88. 窗口1:卖票：票号为：14
  89. 窗口3:卖票：票号为：13
  90. 窗口2:卖票：票号为：12
  91. 窗口1:卖票：票号为：11
  92. 窗口3:卖票：票号为：10
  93. 窗口2:卖票：票号为：9
  94. 窗口1:卖票：票号为：8
  95. 窗口3:卖票：票号为：7
  96. 窗口2:卖票：票号为：6
  97. 窗口1:卖票：票号为：5
  98. 窗口3:卖票：票号为：4
  99. 窗口2:卖票：票号为：3
  100. 窗口1:卖票：票号为：2
  101. 窗口3:卖票：票号为：1
  102. 窗口2:卖票：票号为：0
  103. 窗口1:卖票：票号为：-1
  105. Process finished with exit code 0

3.程序运行图解

image.png
image.png

4.出现的问题及解决措施

1.问题:卖票过程中，出现了重票、错票—>出现了线程的安全问题。
2.问题出现的原因:当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
3.如何解决:当一个线程a在操作ticket的时候， 其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以参与进来开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

5.同步机制解决线程的安全问题

1.同步代码块

  1. synchronized (对象){
  2. // 需要被同步的代码；
  3. }

说明:1.操作共享数据的代码，即为需要被同步的代码。——>不能包多了，也不能包少了。 2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。 3.同步监视器，俗称：锁（任何一个类的对象，都可以充当锁）。 要求：多个线程必须要共用同一把锁。 补充:在实现Runnable 接口创建多线程的方式中，我们可以考居使用this充当同步监视器。 在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

  1. package Thread;
  3. /**
  4.  * @Author 戴尔
  5.  * @Date 2021/12/29 0:57
  6.  * @Version 1.0
  7.  */
  8. class window4 implements Runnable{
  9.     private int ticket=1000000;
  10.     Object obj=new Object();
  12.     @Override
  13.     public void run() {
  14.         while (true){
  15.             synchronized (obj) {
  16.                 if (ticket > 0) {
  17.                     try {
  18.                         Thread.sleep(100);
  19.                     } catch (InterruptedException e) {
  20.                         e.printStackTrace();
  21.                     }
  22.                     System.out.println(Thread.currentThread().getName() + ":卖票：票号为：" + ticket);
  23.                     ticket--;
  24.                 } else {
  25.                     break;
  26.                 }
  27.             }
  28.         }
  29.     }
  30. }
  32. public class ThreadDemo4 {
  33.     public static void main(String[] args) {
  34.         window4 x=new window4();
  36.         Thread x1=new Thread(x);
  37.         Thread x2=new Thread(x);
  38.         Thread x3=new Thread(x);
  40.         x1.setName("窗口一");
  41.         x2.setName("窗口二");
  42.         x3.setName("窗口三");
  44.         x1.start();
  45.         x2.start();
  46.         x3.start();
  47.     }
  48. }
  1. package Thread;
  2. /**
  3.  * @Author 戴尔
  4.  * @Date 2021/12/25 15:29
  5.  * @Version 1.0
  6.  */
  7. class Window1 extends Thread{
  8.     private static int ticket = 100;
  9.     private static  Object obj=new Object();
  11.     @Override
  12.     public void run() {
  13.         while (true) {
  14. //            synchronized (obj) { right
  15. //            synchronized (this){ wrong t1,t2,t3三个对象三把锁
  16.             synchronized (Window1.class){//Class class=Window2.class
  17.                 if (ticket > 0) {
  18.                     try {
  19.                         sleep(100);
  20.                     } catch (InterruptedException e) {
  21.                         e.printStackTrace();
  22.                     }
  23.                     System.out.println(getName() + ":卖票，票号为：" + ticket);
  24.                     ticket--;
  25.                 } else {
  26.                     break;
  27.                 }
  28.             }
  29.         }
  30.     }
  31. }
  32. public class ThreadDemo5 {
  33.     public static void main(String[] args) {
  34.         Window1 w1=new Window1();
  35.         Window1 w2=new Window1();
  36.         Window1 w3=new Window1();
  38.         w1.setName("窗口一");
  39.         w2.setName("窗口二");
  40.         w3.setName("窗口三");
  42.         w1.start();
  43.         w2.start();
  44.         w3.start();
  45.     }
  46. }

image.png

2.同步方法

  1. public synchronized void show (String name){ 
  2.     ......
  3. }

synchronized还可以放在方法声明中，表示整个方法为同步方法。 关于同步方法的总结: 1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。 2.非静态的同步方法，同步监视器是: this 静态的同步方法，同步监视器是:当前类本身

  1. package Thread;
  3. /**
  4.  * @Author 戴尔
  5.  * @Date 2021/12/29 0:57
  6.  * @Version 1.0
  7.  */
  8. class Window2 implements Runnable{
  9.     private int ticket=100;
  10. //    Object obj=new Object();
  12.     @Override
  13.     public void run() {
  14.         while (true){
  15.             show();
  16.             if (ticket==0){
  17.                 break;
  18.             }
  19.         }
  20.     }
  22.     private synchronized void show() {
  23. //        synchronized (this) {
  24.             if (ticket > 0) {
  25.                 try {
  26.                     Thread.sleep(100);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.                 System.out.println(Thread.currentThread().getName() + ":卖票：票号为：" + ticket);
  31.                 ticket--;
  32.             }
  33.         }
  34. }
  37. public class ThreadDemo6{
  38.     public static void main(String[] args) {
  39.         Window2 x= new Window2();
  41.         Thread x1=new Thread(x);
  42.         Thread x2=new Thread(x);
  43.         Thread x3=new Thread(x);
  45.         x1.setName("窗口一");
  46.         x2.setName("窗口二");
  47.         x3.setName("窗口三");
  49.         x1.start();
  50.         x2.start();
  51.         x3.start();
  52.     }
  53. }
  1. package Thread;
  2. /**
  3.  * @Author 戴尔
  4.  * @Date 2021/12/25 15:29
  5.  * @Version 1.0
  6.  */
  7. class Window3 extends Thread{
  9.     private static int ticket = 100;
  11.     @Override
  12.     public void run() {
  13.         while (true) {
  14.             show();
  15.             if (ticket==0){
  16.                 break;
  17.             }
  18.         }
  19.     }
  21.     private static synchronized void show() {
  22. //    private synchronized void show() {
  23.         if (ticket > 0) {
  24.             try {
  25.                 sleep(100);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
  30.             ticket--;
  31.         }
  32.     }
  33. }
  35. public class ThreadDemo7 {
  36.     public static void main(String[] args) {
  37.         Window3 w1=new Window3();
  38.         Window3 w2=new Window3();
  39.         Window3 w3=new Window3();
  41.         w1.setName("窗口一");
  42.         w2.setName("窗口二");
  43.         w3.setName("窗口三");
  45.         w1.start();
  46.         w2.start();
  47.         w3.start();
  48.     }
  49. }

3.同步的优缺点

  • 同步的方式，解决了线程的安全问题。——好处
  • 操作同步代码时，只能有一个线程参与， 其他线程等待。相当于是一个单线程的过程，效率低。——缺点

3.线程安全的单例模式之懒汉式

单例模式：懒汉式——> P437->P324 设计模式

5.线程的通信

6.JDK5.0新增线程创建方式