• 第八章：多线程

    目录

    八：多线程

    8.1：基本概念

    8.2：线程的创建与使用

            8.2.1：Thread类的有关方法

            8.2.2：线程的调度

            8.2.3：两种创建线程方式的比较

    8.3：线程的生命周期

    8.4：线程的同步

            8.4.1：同步代码块&&同步方法

            8.4.2：单例模式的懒汉式修改为线程安全的

            8.4.3：线程的死锁问题

            8.4.4：锁(Lock)

    8.5：线程的通信

    8.6：JDK5.0新增线程创建方式

    八：多线程

    8.1：基本概念

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

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

                    -程序是静态的，进程是动态的

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

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

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

                    -线程作为调度和执行的单位，每一个线程拥有独立的运行栈和程序计数器，线程切换的开销小

                    -一个进程中的多个线程共享相同的内存单元/内存地址空间 -> 它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患

    8.2：线程的创建与使用

            8.2.1：Thread类的有关方法

    1.void start()：启动线程，并执行对象的run()方法

    2.run()：线程在被调度时执行的操作

    3.String getName()：获取当前线程的名称

    4.void setName(String name)：设置该线程的名称

    5.static Thread currentThread()：返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类

    6.static void yield()：线程让步

            >暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

            >若队列中没有同优先级的线程，忽略此方法

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

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

    8.static void sleep(long millis)：(指定时间：毫秒)

            >令当前活动线程在指定时间段内放弃对CPU控制，使其它线程有机会被执行，时间到后重新排队

            >抛出InterruptedException异常

    9.stop()：强制线程生命周期结束，不推荐使用

    10.boolean is Alive()：返回boolean，判断线程是否存活

    1. package com.jiayifeng.java;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-08 16:09
    6.  *
    7.  * 测试Thread中的常用方法
    8.  * 测试Thread中的优先级
    9.  */
    10. class HelloThread extends Thread{
    11.     @Override
    12.     public void run() {
    13.         for(int i = 0;i < 100;i++){
    14.             if(i % 2 == 0){
    15.                 try {
    16.                     sleep(10);
    17.                 } catch (InterruptedException e) {
    18.                     throw new RuntimeException(e);
    19.                 }
    20.                 System.out.println(Thread.currentThread().getName() + ":" +
    21.                         Thread.currentThread().getPriority() + i);
    22.             }
    23.  
    24.             if(i % 20 == 0){
    25.                 this.yield();
    26.             }
    27.         }
    28.     }
    29.     public HelloThread(String name){
    30.         super(name);
    31.     }
    32. }
    33.  
    34. public class ThreadMethodTest {
    35.     public static void main(String[] args) {
    36.         HelloThread t1 = new HelloThread("Thread1");
    37.  
    38. //        t1.setName("线程一");
    39. //        设置分线程的优先级
    40.         t1.setPriority(Thread.MAX_PRIORITY);
    41.         t1.start();
    42.  
    43. //        给主线程命名
    44.         Thread.currentThread().setName("主线程");
    45. //        设置主线程的优先级
    46.         Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
    47.         for(int i = 0;i < 100;i++){
    48.             if(i % 2 != 0){
    49.                 System.out.println(Thread.currentThread().getName() + ":" +
    50.                         Thread.currentThread().getPriority() + i);
    51.             }
    52.  
    53.             if(i == 20){
    54.                 try {
    55.                     t1.join();
    56.                 } catch (InterruptedException e) {
    57.                     throw new RuntimeException(e);
    58.                 }
    59.             }
    60.         }
    61.         System.out.println(t1.isAlive());
    62.     }
    63. }
    1. package com.jiayifeng.java;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-07 19:59
    6.  *
    7.  * translate：
    8.  *        eclipse 中 workspace  相当于 IDEA 中的 project
    9.  *        eclipse 中 project    相当于 IDEA 中的 module
    10.  *
    11.  *  一：多线程的创建，方式一：继承于Thread类
    12.  *  1.创建一个继承于Thread类的子类
    13.  *  2.重写Thread类的run() -> 将此线程执行的操作声明在run()中
    14.  *  3.创建Thread类的子类的对象
    15.  *  4.通过此对象调用start()
    16.  *
    17.  *  例子：遍历100以内的所有偶数
    18.  */
    19. public class ThreadTest {
    20.     public static void main(String[] args) {
    21. //        3.创建Thread类的子类的对象
    22.         MyThread t1 = new MyThread();
    23.  
    24. //        4.通过此对象调用start()
    25.         t1.start(); //start()作用：①使当前的线程开始执行 ②Java虚拟机去调用当前的run()方法
    26.  
    27.         System.out.println("hello");
    28. //        问题一：我们不能通过直接调用run()的方式启动线程
    29. //        t1.run();
    30. //        问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程
    31. //        去执行，会报异常IllegalThreadStateException
    32. //        我们需要重新创建一个线程的对象
    33. //        t1.start();
    34.         MyThread t2 = new MyThread();
    35.         t2.start();
    36.     }
    37. }
    38.  
    39. //1.创建一个继承于Thread类的子类
    40. class MyThread extends Thread{
    41. //    2.重写Thread类的run()
    42.     @Override
    43.     public void run() {
    44.         for(int i = 0;i < 100;i++){
    45.             if(i % 2 == 0){
    46.                 System.out.println(i);
    47.             }
    48.         }
    49.     }
    50. }
    1. package com.jiayifeng.prac;
    2.  
    3. /**
    4.  * @author xiaojia
    5.  * create  2023-09-07 21:20
    6.  * title：创建两个分线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数
    7.  */
    8. public class ThreadDemo {
    9.     public static void main(String[] args) {
    10. //        MyThread1 myThread1 = new MyThread1();
    11. //        myThread1.start();
    12. //        MyThread2 myThread2 = new MyThread2();
    13. //        myThread2.start();
    14.  
    15. //        创建Thread类的匿名子类的方式
    16. //        100以内的偶数
    17.         new Thread(){
    18.             @Override
    19.             public void run() {
    20.                 for(int i = 0;i < 100;i++){
    21.                     if(i % 2 == 0){
    22.                         System.out.println(Thread.currentThread().getName() + ":" + i);
    23.                     }
    24.                 }
    25.             }
    26.         }.start();
    27.  
    28. //        100以内的奇数
    29.         new Thread(){
    30.             @Override
    31.             public void run() {
    32.                 for(int i = 0;i < 100;i++){
    33.                     if(i % 2 != 0){
    34.                         System.out.println(Thread.currentThread().getName() + ":" + i);
    35.                     }
    36.                 }
    37.             }
    38.         }.start();
    39.     }
    40.  
    41. }
    42.  
    43. class MyThread1 extends Thread{
    44.     @Override
    45.     public void run() {
    46.         for(int i = 0;i < 100;i++){
    47.             if(i % 2 == 0){
    48.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    49.             }
    50.         }
    51.     }
    52. }
    53.  
    54. class MyThread2 extends Thread{
    55.     @Override
    56.     public void run() {
    57.         for(int i = 0;i < 100;i++){
    58.             if(i % 2 != 0){
    59.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    60.             }
    61.         }
    62.     }
    63. }
            8.2.2：线程的调度

    调用策略：

            ①时间片

            ②抢占式：高优先级的线程抢占CPU

    Java的调度方法：

            ①同优先级线程组成先进先出队列，使用时间片策略

            ②对高优先级，使用优先调度的抢占式策略

    线程的优先级等级：

            MAX_PRIORITY：10

            MIN_PRIORITY：1

            NORM_PRIORITY：5

    设计的方法：

            getPriority()：返回线程优先值

            setPriority(int newPriority)：改变线程的优先级

    说明：

            线程创建时继承父线程的优先级

            低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用

    1. package com.jiayifeng.java;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-09 14:53
    6.  *
    7.  * 创建多线程的方式二：实现Runnable接口
    8.  * 1.创建一个实现了Runnable接口的类
    9.  * 2.实现类去实现Runnable中的抽象方法：run()
    10.  * 3.创建实现类的对象
    11.  * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
    12.  * 5.通过Thread类的对象调用start()
    13.  */
    14.  
    15. //1.创建一个实现了Runnable接口的类
    16. class MThread implements Runnable{
    17. //   2.实现类去实现Runnable中的抽象方法：run()
    18.     @Override
    19.     public void run() {
    20.         for(int i = 0;i < 100;i++){
    21.             if(i % 2 == 0){
    22.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    23.             }
    24.         }
    25.     }
    26. }
    27. public class ThreadTest1 {
    28.     public static void main(String[] args) {
    29. //        3.创建实现类的对象
    30.         MThread m1 = new MThread();
    31. //        4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
    32.         Thread t1 = new Thread(m1);
    33.         t1.setName("线程一");
    34. //        5.通过Thread类的对象调用start()
    35.         t1.start();
    36.         
    37. //        再启动一个线程，遍历100以内的偶数
    38.         Thread t2 = new Thread(m1);
    39.         t2.setName("线程二");
    40.         t2.start();
    41.     }
    42. }
            8.2.3：两种创建线程方式的比较

    开发中，优先选择实现Runnable接口的方式

    原因：

            1.实现的方式没有类的单继承性的局限性

            2.实现的方式更适合来处理多个线程有共享数据的情况

    联系：public class Thread implements Runnable

    相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中

    8.3：线程的生命周期

    JDK中用Thread.State类定义了线程的几种状态，在线程的一个完整周期中通常用经历如下的五个阶段：

            ①新建：当一个Thread类或其它子类的对象被声明并创建时，新生的线程对象处于新建状态

            ②就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没有分配到CPU资源

            ③运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能

            ④阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时终止自己的执行，进入阻塞状态

            ⑤死亡：线程完成了它的全部工作或线程被提前强制性终止或出现异常导致结束

    8.4：线程的同步

            8.4.1：同步代码块&&同步方法
    1. package com.jiayifeng.prac;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-09 18:15
    6.  *
    7.  * 例子：创建三个窗口卖票，总票数为100张，使用实现Runnable接口的方式
    8.  * 1.在Java中，我们通过同步机制来解决线程的安全问题
    9.  *      方式一：同步代码块
    10.  *      synchronize(同步监视器){
    11.  *          //需要被同步的代码
    12.  *      }
    13.  *      说明：
    14.  *          ①操作共享数据的代码，即为需要被同步的代码
    15.  *          ②共享数据：多个线程共同操作的变量。比如：ticket就是共享数据
    16.  *          ③同步监视器，俗称：锁。任何一个类的对象，都可以充当锁
    17.  *              要求：多个线程必须要共用一把锁
    18.  *
    19.  *      方式二：同步方法
    20.  *          如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的
    21.  *
    22.  *
    23.  * 2.同步的方式，解决了线程的安全问题 --好处
    24.  *   操作同步代码时，只能有一个线程参与，其它线程等待。相当于是一个单线程的过程，效率低  
    25.  *
    26.  */
    27. class Window implements Runnable{
    28.     private int ticket = 100;
    29. //    Object obj = new Object();
    30.  
    31.     @Override
    32.     public void run() {
    33.         while (true) {
    34. //            方式一：
    35.             synchronized (this){
    36. //            此时的this：唯一的Window的对象    方式二：synchronized(obj) {
    37.                 if (ticket > 0) {
    38.                     try {
    39.                         Thread.sleep(100);
    40.                     } catch (InterruptedException e) {
    41.                         e.printStackTrace();
    42.                     }
    43.                     System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
    44.                     ticket--;
    45.                 } else {
    46.                     break;
    47.                 }
    48.             }
    49.         }
    50.     }
    51. }
    52. public class WindowTest {
    53.     public static void main(String[] args) {
    54.         Window w1 = new Window();
    55.  
    56.         Thread t1 = new Thread(w1);
    57.         Thread t2 = new Thread(w1);
    58.         Thread t3 = new Thread(w1);
    59.  
    60.         t1.setName("窗口一");
    61.         t2.setName("窗口二");
    62.         t3.setName("窗口三");
    63.  
    64.         t1.start();
    65.         t2.start();
    66.         t3.start();
    67.     }
    68. }
    69.  
    1. package com.jiayifeng.prac;
    2.  
    3. import javax.jws.Oneway;
    4.  
    5. /**
    6.  * author xiaojia
    7.  * create 2023-09-09 18:49
    8.  *
    9.  * 使用同步代码块解决继承Thread类的方式的线程安全问题
    10.  *
    11.  * 说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同 
    12.  * 步监视器
    13.  */
    14.  
    15. class Window1 extends Thread {
    16.     private static int ticket = 100;
    17.     private static Object obj = new Object();
    18.  
    19.     @Override
    20.     public void run() {
    21.         while (true) {
    22.             synchronized (obj) {
    23.                 if (ticket > 0) {
    24.                     try {
    25.                         Thread.sleep(100);
    26.                     } catch (InterruptedException e) {
    27.                         e.printStackTrace();
    28.                     }
    29.                     System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
    30.                     ticket--;
    31.                 } else {
    32.                     break;
    33.                 }
    34.             }
    35.         }
    36.     }
    37. }
    38.  
    39. public class WindowTest1 {
    40.     public static void main(String[] args) {
    41.         Window1 t1 = new Window1();
    42.         Window1 t2 = new Window1();
    43.         Window1 t3 = new Window1();
    44.  
    45.         t1.setName("窗口1");
    46.         t2.setName("窗口2");
    47.         t3.setName("窗口3");
    48.  
    49.         t1.start();
    50.         t2.start();
    51.         t3.start();
    52.     }
    53. }
    1. package com.jiayifeng.prac;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-10 8:21
    6.  *
    7.  * 使用同步方法解决实现Runnable接口的线程安全问题
    8.  *
    9.  * 关于同步方法的总结：
    10.  *      1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
    11.  *      2.非静态的同步方法，同步监视器是：this
    12.  *      3.静态的同步方法，同步监视器是：当前类本身
    13.  */
    14. class Window2 implements Runnable {
    15.     private int ticket = 100;
    16.  
    17.     @Override
    18.     public void run() {
    19.         while (true) {
    20.             show();
    21.         }
    22.     }
    23.  
    24.     private synchronized void show() { //同步监视器：this
    25. //        synchronized (this) {
    26.             if (ticket > 0) {
    27.                 try {
    28.                     Thread.sleep(100);
    29.                 } catch (InterruptedException e) {
    30.                     e.printStackTrace();
    31.                 }
    32.                 System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
    33.                 ticket--;
    34.             }
    35. //        }
    36.     }
    37. }
    38.  
    39. public class WindowTest2 {
    40.     public static void main(String[] args) {
    41.         Window2 w2 = new Window2();
    42.  
    43.         Thread t1 = new Thread(w2);
    44.         Thread t2 = new Thread(w2);
    45.         Thread t3 = new Thread(w2);
    46.  
    47.         t1.setName("窗口一");
    48.         t2.setName("窗口二");
    49.         t3.setName("窗口三");
    50.  
    51.         t1.start();
    52.         t2.start();
    53.         t3.start();
    54.     }
    55. }
    1. package com.jiayifeng.prac;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-10 8:37
    6.  *
    7.  * 使用同步方法处理继承Thread类的方式中的线程安全问题
    8.  */
    9. class Window3 extends Thread {
    10.     private static int ticket = 100;
    11.  
    12.     @Override
    13.     public void run() {
    14.         while (true) {
    15.             show();
    16.         }
    17.     }
    18.     private static synchronized  void show(){ //同步监视器：Window3.class
    19. //    private synchronized void show() { //同步监视器：t1,t2,t3，此种解决方式是错误的
    20.         if (ticket > 0) {
    21.             try {
    22.                 Thread.sleep(100);
    23.             } catch (InterruptedException e) {
    24.                 e.printStackTrace();
    25.             }
    26.             System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
    27.             ticket--;
    28.         }
    29.     }
    30. }
    31.  
    32. public class WindowTest3 {
    33.     public static void main(String[] args) {
    34.         Window3 t1 = new Window3();
    35.         Window3 t2 = new Window3();
    36.         Window3 t3 = new Window3();
    37.  
    38.         t1.setName("窗口1");
    39.         t2.setName("窗口2");
    40.         t3.setName("窗口3");
    41.  
    42.         t1.start();
    43.         t2.start();
    44.         t3.start();
    45.     }
    46. }
            8.4.2：单例模式的懒汉式修改为线程安全的
    1. package com.jiayifeng.java.java1;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-10 8:55
    6.  *
    7.  * 快捷键：
    8.  *  1.alt + shift + z：打开surround with
    9.  *  2.Ctrl + alt + enter：向上开辟一行
    10.  *  3.tab + s：构造器
    11.  * 一：使用同步机制将单例模式中的懒汉式改写为线程安全的
    12.  */
    13. public class BankTest {
    14.  
    15. }
    16.  
    17. class Bank{
    18.     private Bank(){}
    19.  
    20.     private static Bank instance = null;
    21. //    效率更高
    22.     public static  Bank getInstance() {
    23.         if (instance == null) {
    24.             synchronized (Bank.class) {
    25.                 if (instance == null) {
    26.                     instance = new Bank();
    27.                 }
    28.             }
    29.         }
    30.             return instance;
    31.     }
    32. }
            8.4.3：线程的死锁问题

    死锁：

            不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

            出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

    解决方法：

            专门的算法、原则

            尽量减少同步资源的定义

            尽量避免嵌套同步

    1. package com.jiayifeng.java1;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-10 9:22
    6.  *
    7.  * 线程的死锁问题
    8.  */
    9. public class ThreadTest {
    10.     public static void main(String[] args) {
    11.         StringBuffer s1 = new StringBuffer();
    12.         StringBuffer s2 = new StringBuffer();
    13.  
    14. //        匿名创建
    15.         new Thread(){
    16.             @Override
    17.             public void run() {
    18.                 synchronized (s1){
    19.                     s1.append("a");
    20.                     s2.append(1);
    21.  
    22.                     try {
    23.                         Thread.sleep(100);
    24.                     } catch (InterruptedException e) {
    25.                         e.printStackTrace();
    26.                     }
    27.  
    28.  
    29.                     synchronized (s2){
    30.                         s1.append("b");
    31.                         s2.append(2);
    32.  
    33.                         System.out.println(s1);
    34.                         System.out.println(s2);
    35.                     }
    36.                 }
    37.             }
    38.         }.start();
    39.  
    40.         new Thread(new Runnable() {
    41.             @Override
    42.             public void run() {
    43.                 synchronized (s2){
    44.                     s1.append("c");
    45.                     s2.append(3);
    46.  
    47.                     try {
    48.                         Thread.sleep(100);
    49.                     } catch (InterruptedException e) {
    50.                         e.printStackTrace();
    51.                     }
    52.  
    53.                     synchronized (s1){
    54.                         s1.append("d");
    55.                         s2.append(4);
    56.  
    57.                         System.out.println(s1);
    58.                         System.out.println(s2);
    59.                     }
    60.                 }
    61.             }
    62.         }).start();
    63.     }
    64. }
            8.4.4：锁(Lock)

    从JDK 5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当

    1. package com.jiayifeng.java1;
    2.  
    3. import java.util.concurrent.locks.ReentrantLock;
    4.  
    5. /**
    6.  * author xiaojia
    7.  * create 2023-09-10 9:44
    8.  *
    9.  * 一：解决线程安全问题的方式三：Lock --- JDK 5.0新增
    10.  * 1.面试题：synchronized与lock的异同？
    11.  *      相同：两者都可以解决线程安全问题
    12.  *      不同：synchronized机制在执行完相应的同步代码后，自动的释放同步监视器
    13.  *           lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock())
    14.  *           
    15.  * 2.优先使用顺序：
    16.  *      lock -> 同步代码块（已经进入了方法体，分配了相应的资源） -> 同步方法（在方法体之 
    17.  *      外）
    18.  */
    19.  
    20. class Window implements Runnable{
    21.     private int ticket = 100;
    22. //    1.实例化
    23.     private ReentrantLock lock = new ReentrantLock();
    24.     @Override
    25.     public void run() {
    26.         while(true){
    27.             try{
    28. //                2.调用锁定方法lock()
    29.                 lock.lock();
    30.                 if(ticket > 0){
    31.                     try {
    32.                         Thread.sleep(100);
    33.                     } catch (InterruptedException e) {
    34.                         e.printStackTrace();
    35.                     }
    36.                     System.out.println(Thread.currentThread().getName() + "：售票，票号为；" + ticket);
    37.                     ticket--;
    38.                 }else{
    39.                     break;
    40.                 }
    41.             }finally {
    42. //                3.调用解锁的方法：unlock()
    43.                 lock.unlock();
    44.             }
    45.  
    46.         }
    47.  
    48.     }
    49. }
    50. public class LockTest {
    51.     public static void main(String[] args) {
    52.         Window w = new Window();
    53.         Thread t1 = new Thread(w);
    54.         Thread t2 = new Thread(w);
    55.         Thread t3 = new Thread(w);
    56.  
    57.         t1.setName("窗口1");
    58.         t2.setName("窗口2");
    59.         t3.setName("窗口3");
    60.  
    61.         t1.start();
    62.         t2.start();
    63.         t3.start();
    64.     }
    65. }

    8.5：线程的通信

    1. package com.jiayifeng.java.java2;
    2.  
    3. /**
    4.  * author xiaojia
    5.  * create 2023-09-10 10:25
    6.  *
    7.  * 1.线程通信的example：使用两个线程打印1-100.线程1，线程2交替打印
    8.  * 2.涉及到的三个方法：
    9.  *    wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
    10.  *    notify():一旦执行此方法，就会唤醒被wait()的一个线程。如果有多个线程，就唤醒
    11.  *    优先级高的
    12.  *    notifyAll():一旦执行此方法，就会唤醒所有被wait的线程
    13.  * 3.说明：
    14.  *    这三个方法必须使用在同步代码块和同步方法中
    15.  *    这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现异常
    16.  *    这三个方法是定义在java.lang.Object类中的
    17.  * 4.面试题：sleep()和wait()的异同？
    18.  *    ①相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态
    19.  *    ②不同点：
    20.  *         1>两个方法声明的位置不同：Thread类中声明sleep(),Object()类中声明wait()
    21.  *         2>调用的要求不同：sleep()可以在任何需要的场景下使用，wait()必须使用在
    22.  *         同步代码块或同步方法中
    23.  *         3>是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()
    24.  *         不会释放锁，wait()会释放锁
    25.  */
    26.  
    27. class Number implements Runnable{
    28.     private int number = 1;
    29.     @Override
    30.     public void run() {
    31.         while (true) {
    32.             synchronized (this) {
    33. //                唤醒阻塞的线程
    34.                 notify();
    35.                 if (number < 100) {
    36.                     try {
    37.                         Thread.sleep(100);
    38.                     } catch (InterruptedException e) {
    39.                         e.printStackTrace();
    40.                     }
    41.                     System.out.println(Thread.currentThread().getName() + ":" + number);
    42.                     number++;
    43.  
    44.                     try {
    45. //                        使得调用如下wait()方法的线程进入阻塞状态
    46.                         wait();
    47.                     } catch (InterruptedException e) {
    48.                         e.printStackTrace();
    49.                     }
    50.                 } else {
    51.                     break;
    52.                 }
    53.             }
    54.         }
    55.     }
    56. }
    57. public class CommunicationTest {
    58.     public static void main(String[] args) {
    59.         Number n1 = new Number();
    60.         Thread t1 = new Thread(n1);
    61.         Thread t2 = new Thread(n1);
    62.  
    63.         t1.setName("线程1");
    64.         t2.setName("线程2");
    65.  
    66.         t1.start();
    67.         t2.start();
    68.     }
    69. }

    8.6：JDK5.0新增线程创建方式

    新增方式一：实现Callable接口

            与使用Runnable相比，Callable功能更强大些

                    -相比run()方法，可以有返回值

                    -方法可以抛出异常

                    -支持泛型的返回值

                    -需要借助FutureTask类，比如获取返回结果

            Future接口：

                    -可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等

                    -FutureTask是Future接口的唯一的实现类

                    -FutureTask同时实现了Runnable，Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

    1. package com.jiayifeng.java.java2;
    2.  
    3. import java.util.concurrent.Callable;
    4. import java.util.concurrent.ExecutionException;
    5. import java.util.concurrent.FutureTask;
    6.  
    7. /**
    8.  * author xiaojia
    9.  * create 2023-09-10 14:32
    10.  *
    11.  * 一：创建线程的方式三：实现Callable接口 --- JDK 5.0新增
    12.  */
    13.  
    14. //1.创建一个实现Callable的实现类
    15. class NumThread implements Callable{
    16. //2.实现call方法，将此线程需要执行的操作声明在call()中
    17. 	@Override
    18. 	public Object call() throws Exception {
    19. 		int sum = 0;
    20. 		for(int i = 0;i <= 100;i++){
    21. 			if (i % 2 == 0) {
    22. 				System.out.println(i);
    23. 				sum += i;
    24. 			}
    25. 		}
    26. 		return sum;
    27. 	}
    28. }
    29. public class ThreadNew {
    30. 	public static void main(String[] args) {
    31. //        3.创建Callable接口实现类的对象
    32. 		NumThread n1 = new NumThread();
    33. //        4.将此Callable接口实现类的对象作为传递到FutureTask的构造器中，创建
    34. //        FutureTask的对象
    35. 		FutureTask f1 = new FutureTask(n1);
    36. //        5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread
    37. //        对象，并调用start()方法
    38. 		new Thread(f1).start();
    39.  
    40. 		try {
    41. //            6.获取Callable中call方法的返回值
    42. //            get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
    43. 			Object sum = f1.get();
    44. 			System.out.println("总和为：" + sum);
    45. 		} catch (InterruptedException e) {
    46. 			e.printStackTrace();
    47. 		} catch (ExecutionException e) {
    48. 			e.printStackTrace();
    49. 		}
    50. 	}
    51. }

    新增方式二：使用线程池

            思路：提前创好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用

            好处：

                    ->提高相应速度(减少了创建新线程的时间)

                    ->降低资源消耗(重复利用线程池中线程，不需要每次都创建)

                    ->便于线程管理

                            -corePoolSize：核心池的大小

                            -maximumPoolSize：最大线程数

                            -keepAliveTime：线程没有任务时最多保持多长时间后会终止

    1. package com.jiayifeng.java.java2;
    2.  
    3. import java.util.concurrent.ExecutorService;
    4. import java.util.concurrent.Executors;
    5. import java.util.concurrent.ThreadPoolExecutor;
    6. /**
    7.  * author xiaojia
    8.  * create 2023-09-10 15:54
    9.  *
    10.  * 一：创建线程的方式四：使用线程池
    11.  */
    12.  
    13. class NumberThread implements Runnable{
    14.      @Override
    15.      public void run() {
    16.           for(int i = 0;i <= 100;i++){
    17.                if (i % 2 == 0) {
    18.                     System.out.println(Thread.currentThread().getName() + ":" + i);
    19.                }
    20.           }
    21.      }
    22. }
    23.  
    24. public class ThreadPool {
    25.      public static void main(String[] args) {
    26. //          1.提供指定线程数量的线程池
    27.           ExecutorService serivce = Executors.newFixedThreadPool(10);
    28.  
    29.           ThreadPoolExecutor service1 = (ThreadPoolExecutor) serivce;
    30.  
    31. //          设置线程池的属性
    32.           System.out.println(serivce.getClass());
    33.           service1.getCorePoolSize();
    34.  
    35. //          2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
    36.           serivce.execute(new NumberThread()); //适用于Runnable
    37. //          serivce.submit(); //适用于Callable
    38.           
    39. //          3.关闭连接池
    40.           serivce.shutdown(); //关闭线程
    41.      }
    42. }
  • 相关阅读:
    操作系统【OS】线程的分类
    《Linux设备驱动开发详解》之udev用户空间设备管理
    类和对象（中上）
    【RocketMQ 十】RocketMQ工作原理之消息生产及存储
    微调 Florence-2 - 微软的尖端视觉语言模型
    ubuntu 20.04 SD 卡分区类型 msdos 改为 GPT 的方法
    06-linux下的软件包管理 RPM YUM
    解决Verilog中的generate_for问题，就是生成多个块，其区别于for块。
    深入浅出WMS之出库流程解析
    html支持网络串流flv视频播放
  • 原文地址：https://blog.csdn.net/weixin_63925896/article/details/132744363