✅作者简介：大家好我是@每天都要敲代码，一位材料转码农的选手，希望一起努力，一起进步！
📃个人主页：@每天都要敲代码的个人主页

🔥系列专栏：JavaSE从入门到精通
💬推荐一款模拟面试、刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习

目录

线程内容补充

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的时候就备份一次。所有的用户线程
如果结束了，守护线程自动退出，没有必要进行数据备份了。

模拟守护线程

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

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

package com.bjpowernode.java.thread;
// 守护线程
public class ThreadTest014 {
    public static void main(String[] args) {
        Thread t = new BackThread();
        t.setName("备份数据的线程");

        // 启动线程之前，将线程设置为守护线程
        t.setDaemon(true);

        t.start();

        // 主线程是用户线程
        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName()+"--->"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class BackThread extends Thread{

    public void run() {
        int i = 0;
        // 即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止。
        while(true){
            System.out.println(Thread.currentThread().getName()+"--->"+ (++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2. 定时器

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

        例如：每周要进行银行账户的总账操作。

                   每天要进行数据的备份操作。

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

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

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

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

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

package com.bjpowernode.java.thread;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

// 使用定时器指定定时对象
public class ThreadTest15 {
    public static void main(String[] args) throws Exception {
        // 创建定时器对象
        Timer timer = new Timer();
        // Timer timer = new Timer(true); // 守护进程的方式

        // 指定定时任务
        // timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);

        // 获取第一次执行时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2022-7-31 22:19:00");

        timer.schedule(new logTimerTask(),firstTime,10*1000); // 间隔10秒执行一次
        
    }

}

// 定时任务类，继承TimerTask
// 假设这是一个记录日志的定时任务
class logTimerTask extends TimerTask{ // TimerTask是一个抽象类
    public void run() {
        // 编写执行的定时任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(new Date());
        System.out.println(strTime+"：完成了一次数据备份");
    }
}

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

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

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

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

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

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

// 实现线程的第三种方式，实现callable接口
public class ThreadTest08 {
    public static void main(String[] args) throws Exception{
        //第一步：创建一个“未来任务类”
        // 参数既可以传Runnable(没有返回值),也可以传Callable(有返回值)
        FutureTask task = new FutureTask(new MyCallable()); // Callable接口实现类对象

        // 创建线程对象
        Thread t = new Thread(task);
        // 启动线程
        t.start();

        // main方法是在主线程中，在主线程中，怎么获取t线程的返回值
        // get()方法的执行会导致“当前线程阻塞”，要等拿到call()方法return的结果
        Object obj = task.get();
        System.out.println("线程执行结果："+obj);

        // main方法这里的程序要想执行必须等待get()方法的结束
        // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果
        // 另一个线程执行是需要时间的。
        System.out.println("Hello World");

    }
}


class MyCallable implements Callable{
    // 重写call()方法，ctrl+O；
    // call()方法就相当于run()方法，只不过run()方法有返回值
    public Object call() throws Exception {
        System.out.println("call method begin");
        Thread.sleep(1000*10);
        System.out.println("call method end");
        int a = 10;
        int b = 20;
        return a+b; //自动装箱（返回的是Object类型，300结果会变成Integer）
    }
}

/*执行结果：
 call method begin
 call method end
 线程执行结果：30
 Hello World
*/

采用匿名内部类的方式 

package com.bjpowernode.java.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask; 
// 采用匿名内部类的方式
public class ThreadTest16 {
    public static void main(String[] args) throws Exception, InterruptedException {
        // 匿名内部类的方式
        FutureTask task = new FutureTask(new Callable() {
            public Object call() throws Exception {   
                System.out.println("call method begin");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;
                return a + b; //自动装箱(300结果变成Integer)
            }
        });

        // 创建线程对象
        Thread t = new Thread(task);
        // 启动线程
        t.start();
        Object obj = task.get();
        System.out.println(obj);

        System.out.println("Hello World!");


    }
}

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()方法作用      

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

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

（4）notify()方法作用        

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

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

生产者和消费者模式

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

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

（1）使用wait方法和notify方法实现“生产者和消费者模式”
（2）什么是“生产者和消费者模式”？
     生产线程负责生产，消费线程负责消费。
     生产线程和消费线程要达到均衡。
     这是一种特殊的业务需求，在这种特殊的情况下需要使用wait方法和notify方法。
（3）wait和notify方法不是线程对象的方法，是普通java对象都有的方法
（4）wait方法和notify方法建立在线程同步的基础之上；因为多线程要同时操作一个仓库。有线程安全问题。
（5）wait方法作用：o.wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
（6）notify方法作用：o.notify()让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。
（7）模拟这样一个需求：
    1）仓库我们采用List集合
    2）List集合中假设只能存储1个元素
    3）1个元素就表示仓库满了
    4）如果List集合中元素个数是0，就表示仓库空了
    5）保证List集合中永远都是最多存储1个元素

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

package com.bjpowernode.java.thread;

import java.util.ArrayList;
import java.util.List;

public class ThreadTest17 {
    public static void main(String[] args) {
        // 创建1个仓库对象，共享的
        List list = new ArrayList();
        // 创建2个线程对象
        Thread t1 = new Thread(new Producer(list));
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

        t1.start();
        t2.start();

    }

}

// 生产线程
class Producer implements Runnable{
    // 仓库
    private List list;
    // 通过构造方法传过来
    public Producer(List list) {
        this.list = list;
    }

    public void run() {
        // 一直生产（使用死循环）
         while(true){
             // 给仓库对象List加锁
             synchronized (list){
                 if(list.size()>0){ // 大于0,说明仓库中已经有一个元素了
                     try {
                         // 当前线程进入等待状态，并且释放Producer之前占有的List集合的锁
                         list.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }

                 // 如果仓库空，生产
                 Object obj = new Object();
                 list.add(obj);
                 System.out.println(Thread.currentThread().getName()+"--->"+obj);

                 // 唤醒消费者进行消费
                 list.notify();
             }
         }
    }
}

// 消费线程
class Consumer implements Runnable{
    // 仓库
    private List list;
    // 通过构造方法传过来
    public Consumer(List list) {
        this.list = list;
    }

    public void run() {
        // 一直消费
        while(true){
            synchronized (list){
                if(list.size() == 0){
                    try {
                        // 仓库已经空了
                        // 消费者线程等待，释放掉List集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 说明仓库中有数据，消费者进行消费
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName()+"--->"+obj);

                // 唤醒生产者生产
                list.notify();
            }
        }
    }
}

结束语

今天的分享就到这里啦！快快通过下方链接注册加入刷题大军吧！各种大厂面试真题在等你哦！
💬刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习