• 深入理解多线程（第三篇）

    目录

    线程内容补充

    1. 守护线程

    2. 定时器

    3. 实现线程的第三种方式：实现Callable接口

    4. wait和notify(生产者和消费者模式)

    线程内容补充

    1、守护线程
    2、定时器
    3、实现线程的第三种方式：FutureTask方式，实现Callable接口。（JDK8新特性）
    4、关于Object类中的wait和notify方法。（生产者和消费者模式）

    1. 守护线程

    （1）java语言中线程分为两大类：
    一类是：用户线程
    一类是：守护线程（后台线程），其中具有代表性的就是垃圾回收线程(守护线程)

    （2）守护线程的特点：一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。   
    注意：主线程main方法是一个用户线程。

    （3）守护线程用在什么地方呢？
    例如：每天00:00的时候系统数据自动备份；这个需要使用到定时器，并且我们可以将定时器设置为守护线程； 一直在那里看着，每到00:00的时候就备份一次，所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

    模拟守护线程

    主线程用户线程结束；守护线程也会自动终止，即使死循环也不行！

    将一个线程设置为守护线程： t.setDaemon(true)；一定是在启动线程(t.start)之前设置为守护线程(t.setDaemon(true))！

    例如：下面主线程main运行完，备份数据的线程也会自动终止

    1. package com.bjpowernode.java.thread;
    2. // 守护线程
    3. public class ThreadTest014 {
    4.     public static void main(String[] args) {
    5.         Thread t = new BackThread();
    6.         t.setName("备份数据的线程");
    7.  
    8.         // 启动线程之前，将线程设置为守护线程
    9.         t.setDaemon(true);
    10.  
    11.         t.start();
    12.  
    13.         // 主线程是用户线程
    14.         for (int i = 0; i <10 ; i++) {
    15.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    16.             try {
    17.                 Thread.sleep(1000);
    18.             } catch (InterruptedException e) {
    19.                 e.printStackTrace();
    20.             }
    21.         }
    22.  
    23.     }
    24. }
    25.  
    26. class BackThread extends Thread{
    27.  
    28.     public void run() {
    29.         int i = 0;
    30.         // 即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止。
    31.         while(true){
    32.             System.out.println(Thread.currentThread().getName()+"--->"+ (++i));
    33.             try {
    34.                 Thread.sleep(1000);
    35.             } catch (InterruptedException e) {
    36.                 e.printStackTrace();
    37.             }
    38.         }
    39.     }
    40. }

    2. 定时器

    （1）定时器的作用： 间隔特定的时间，执行特定的程序。

    例如：每周要进行银行账户的总账操作；每天要进行数据的备份操作。

    （2）在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，那么在java中其实可以采用多种方式实现：                
    第一种方式：可以使用sleep方法睡眠，设置睡眠时间，每到这个时间点醒来，执行任务，这种方式是最原始的定时器。

    第二种方式：在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。

    第三种方式：在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。

    （3）核心：继承TimerTask类，创建Timer对象，调用schedule方法

    第一步：编写定时任务类继承TimerTask类，重写run方法，在里面编写具体的定时任务逻辑

    第二步：创建Timer对象，调用Timer对象的schedlue方法，里面有三个参数：

    schedule(定时任务，第一次执行时间，间隔多久执行一次)

    ①第一个参数是继承TimerTask类的定时任务类；

    ②第二个参数是Date类型，第一次执行时间或者说从何时开始第一次执行；

    ③第三个参数是间隔多久执行一次，单位是毫秒数；

    1. package com.bjpowernode.java.thread;
    2.  
    3. import java.text.SimpleDateFormat;
    4. import java.util.Date;
    5. import java.util.Timer;
    6. import java.util.TimerTask;
    7.  
    8. // 使用定时器指定定时对象
    9. public class ThreadTest15 {
    10.     public static void main(String[] args) throws Exception {
    11.         // 创建定时器对象
    12.         Timer timer = new Timer();
    13.         // Timer timer = new Timer(true); // 守护进程的方式
    14.  
    15.         // 指定定时任务
    16.         // timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
    17.  
    18.         // 获取第一次执行时间
    19.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    20.         Date firstTime = sdf.parse("2022-7-31 22:19:00");
    21.  
    22.         timer.schedule(new logTimerTask(),firstTime,10*1000); // 间隔10秒执行一次
    23.         
    24.     }
    25.  
    26. }
    27.  
    28. // 定时任务类，继承TimerTask
    29. // 假设这是一个记录日志的定时任务
    30. class logTimerTask extends TimerTask{ // TimerTask是一个抽象类
    31.     public void run() {
    32.         // 编写执行的定时任务
    33.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    34.         String strTime = sdf.format(new Date());
    35.         System.out.println(strTime+"：完成了一次数据备份");
    36.     }
    37. }

    3. 实现线程的第三种方式：实现Callable接口

    （1）实现线程的第三种方式：实现Callable接口
    优点：可以获取到线程的执行结果。
    缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。

    （2）实现线程的第三种方式：实现Callable接口。（JDK8新特性）
    这种方式实现的线程可以获取线程的返回值；之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

    思考：系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？使用第三种方式：实现Callable接口

    （3）这种方式执行效率较低，在获取返回值时有可能造成当前线程阻塞！

    （4）实现步骤：

    第一步：创建一个类实现Callable接口，重写里面的call()方法；call方法就相当于前面说的run方法，只不过call方法是有返回值的Object；run方法没有返回值是void；

    第二步：先创建实现Callable接口的实现类；

    第三步：在创建一个未来任务类FutureTask，调用有参构造方法，参数就是上面的实现类；

    第四步：创建Thread类，把未来任务类FutureTask对象传进去；最终调用start方法启动线程

    （5）小总结：

    ①从下面代码可以看出确实可以拿到返回值，通过调用未来任务类FutureTask的get方法；默认返回的一个Object类型，包括我们重写call方法时返回的也是一个Object类型；但是我们也可以使用泛型机制，返回指定的数据类型。

    ②在获取数据可能会导致当前线程阻塞的问题，我们要想拿到call方法的返回值，必须等到call方法结束，return我们才可以拿到；在return之前，当前线程就会处于阻塞状态！

    1. import java.util.concurrent.Callable;
    2. import java.util.concurrent.FutureTask;
    3.  
    4. // 实现线程的第三种方式，实现callable接口
    5. public class ThreadTest08 {
    6.     public static void main(String[] args) throws Exception{
    7.         //第一步：创建一个“未来任务类”
    8.         // 参数既可以传Runnable(没有返回值),也可以传Callable(有返回值)
    9.         FutureTask task = new FutureTask(new MyCallable()); // Callable接口实现类对象
    10.  
    11.         // 创建线程对象
    12.         Thread t = new Thread(task);
    13.         // 启动线程
    14.         t.start();
    15.  
    16.         // main方法是在主线程中，在主线程中，怎么获取t线程的返回值
    17.         // get()方法的执行会导致“当前线程阻塞”，要等拿到call()方法return的结果
    18.         Object obj = task.get();
    19.         System.out.println("线程执行结果："+obj);
    20.  
    21.         // main方法这里的程序要想执行必须等待get()方法的结束
    22.         // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
    23.         // 另一个线程执行是需要时间的。
    24.         System.out.println("Hello World");
    25.  
    26.     }
    27. }
    28.  
    29.  
    30. class MyCallable implements Callable{
    31.     // 重写call()方法，ctrl+O；
    32.     // call()方法就相当于run()方法，只不过run()方法有返回值
    33.     public Object call() throws Exception {
    34.         System.out.println("call method begin");
    35.         Thread.sleep(1000*10);
    36.         System.out.println("call method end");
    37.         int a = 10;
    38.         int b = 20;
    39.         return a+b; //自动装箱（返回的是Object类型，300结果会变成Integer）
    40.     }
    41. }
    42.  
    43. /*执行结果：
    44.  call method begin
    45.  call method end
    46.  线程执行结果：30
    47.  Hello World
    48. */
    49.

    采用匿名内部类的方式 

    1. package com.bjpowernode.java.thread;
    2. import java.util.concurrent.Callable;
    3. import java.util.concurrent.FutureTask; 
    4. // 采用匿名内部类的方式
    5. public class ThreadTest16 {
    6.     public static void main(String[] args) throws Exception, InterruptedException {
    7.         // 匿名内部类的方式
    8.         FutureTask task = new FutureTask(new Callable() {
    9.             public Object call() throws Exception {   
    10.                 System.out.println("call method begin");
    11.                 Thread.sleep(1000 * 10);
    12.                 System.out.println("call method end!");
    13.                 int a = 100;
    14.                 int b = 200;
    15.                 return a + b; //自动装箱(300结果变成Integer)
    16.             }
    17.         });
    18.  
    19.         // 创建线程对象
    20.         Thread t = new Thread(task);
    21.         // 启动线程
    22.         t.start();
    23.         Object obj = task.get();
    24.         System.out.println(obj);
    25.  
    26.         System.out.println("Hello World!");
    27.  
    28.  
    29.     }
    30. }

    4. wait和notify(生产者和消费者模式)

    （1）关于Object类中的wait和notify方法（生产者和消费者模式）

    T线程在o对象上活动，T线程是当前线程对象；当调用o.wait()方法后，当前线程进入等待状态。o.notify()方法的调用可以让正在o对象上等待的线程唤醒。

    例如：我走在大街上（对象o），有人要打我(线程T)；我说“等会别打脸“（相当于调用了o.wait()）；“继续吧”（相当于调用了o.notify()）

    （2）wait()和notify()方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方法是Object类中自带的。wait方法和notify方法不是通过线程对象调用！

    （3）wait()方法作用 

    表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。     

    1. Object o = new Object();
    2. o.wait();

    （4）notify()方法作用        

    表示：唤醒正在o对象上等待的线程。还有一个notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程。

    1. Object o = new Object();
    2. o.notify();

    生产者和消费者模式

    生产者和消费者模式是为了专门解决某个特定需求的：

    一个线程负责生产，一个线程负责消费；最终要达到生产和消费平衡 

    （1）使用wait方法和notify方法实现“生产者和消费者模式”
    （2）什么是“生产者和消费者模式”？
         生产线程负责生产，消费线程负责消费。
         生产线程和消费线程要达到均衡。
         这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。
    （3）wait和notify方法不是线程对象的方法，是普通java对象都有的方法。
    （4）wait方法和notify方法建立在线程同步synchronzied的基础之上；因为多线程要同时操作一个仓库；有线程安全问题。
    （5）wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
    （6）notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁

    模拟这样一个需求：

    （1）仓库我们采用List集合；
    （2）List集合中假设只能存储1个元素；
    （3）1个元素就表示仓库满了；
    （4）如果List集合中元素个数是0，就表示仓库空了；
    （5）保证List集合中永远都是最多存储1个元素；

    （6）必须做到这种效果：生产1个消费1个；

    1. package com.bjpowernode.java.thread;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class ThreadTest17 {
    7.     public static void main(String[] args) {
    8.         // 创建1个仓库对象，共享的
    9.         List list = new ArrayList();
    10.         // 创建2个线程对象
    11.         Thread t1 = new Thread(new Producer(list));
    12.         Thread t2 = new Thread(new Consumer(list));
    13.  
    14.         t1.setName("生产者线程");
    15.         t2.setName("消费者线程");
    16.  
    17.         t1.start();
    18.         t2.start();
    19.  
    20.     }
    21.  
    22. }
    23.  
    24. // 生产线程
    25. class Producer implements Runnable{
    26.     // 仓库
    27.     private List list;
    28.     // 通过构造方法传过来
    29.     public Producer(List list) {
    30.         this.list = list;
    31.     }
    32.  
    33.     public void run() {
    34.         // 一直生产（使用死循环）
    35.          while(true){
    36.              // 给仓库对象List加锁
    37.              synchronized (list){
    38.                  if(list.size()>0){ // 大于0,说明仓库中已经有一个元素了
    39.                      try {
    40.                          // 当前线程进入等待状态，并且释放Producer之前占有的List集合的锁
    41.                          list.wait();
    42.                      } catch (InterruptedException e) {
    43.                          e.printStackTrace();
    44.                      }
    45.                  }
    46.  
    47.                  // 如果仓库空，生产
    48.                  Object obj = new Object();
    49.                  list.add(obj);
    50.                  System.out.println(Thread.currentThread().getName()+"--->"+obj);
    51.  
    52.                  // 唤醒消费者进行消费
    53.                  list.notify();
    54.              }
    55.          }
    56.     }
    57. }
    58.  
    59. // 消费线程
    60. class Consumer implements Runnable{
    61.     // 仓库
    62.     private List list;
    63.     // 通过构造方法传过来
    64.     public Consumer(List list) {
    65.         this.list = list;
    66.     }
    67.  
    68.     public void run() {
    69.         // 一直消费
    70.         while(true){
    71.             synchronized (list){
    72.                 if(list.size() == 0){
    73.                     try {
    74.                         // 仓库已经空了
    75.                         // 消费者线程等待，释放掉List集合的锁
    76.                         list.wait();
    77.                     } catch (InterruptedException e) {
    78.                         e.printStackTrace();
    79.                     }
    80.                 }
    81.  
    82.                 // 说明仓库中有数据，消费者进行消费
    83.                 Object obj = list.remove(0);
    84.                 System.out.println(Thread.currentThread().getName()+"--->"+obj);
    85.  
    86.                 // 唤醒生产者生产
    87.                 list.notify();
    88.             }
    89.         }
    90.     }
    91. }

  • 相关阅读:
    Java excel poi 读取已有文件 ，动态插入一列数据
    Rsync已过时？替代文件同步方式了解一下
    论文解读（DAGNN）《Towards Deeper Graph Neural Networks》
    python ⾯向对象
    如何压缩图片的大小？这两个方法了解过吗
    nginx--正向代理、反向代理及负载均衡（图解+配置）
    【每日一道LeetCode】——191. 位1的个数
    内存泄漏，内存溢出，抽象类和接口，netstat、ping、ifconfig的区别
    自动化测试：Selenium中的时间等待
    课题学习(三)----倾角和方位角的动态测量方法（基于陀螺仪的测量系统）
  • 原文地址：https://blog.csdn.net/m0_61933976/article/details/126228963