六、守护线程

目录

守护线程

 定时器

生产者和消费者模式

---

守护线程

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

​ 守护线程的特点：
​ 一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。

​ 注意：主线程main方法是一个用户线程。

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

package 多线程.守护线程;

/*
守护线程
 */
public class Test14 {
    public static void main(String[] args) {
        Thread t= new BakDtaThread();
        t.setName("T1");
        //启动线程之前，将线程设置为守护线程
        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 BakDtaThread 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();
            }
        }
    }
}

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

可以看到T1线程设置为守护线程之后，他会在所有线程执行完成之后执行守护线程

 定时器

构造方法

Timer()	创建一个定时器
Timer(boolean isDaemon)	isDaemon为true为守护线程定时器
Timer(String name)	创建一个定时器，其线程名字为name
Timer(String name, boolean isDaemon)	有参构造
void schedule(TimerTask task, Date firstTime, long period)	安排指定的任务在指定的时间开始进行重复的固定延迟执行
void cancel()	终止定时器

package 多线程.守护线程;

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

class TimerTest02{
    public static void main(String[] args) {
        Timer timer = new Timer();
        String firstTimeStr = "2022-12-04 19:26:00";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date firstTime = sdf.parse(firstTimeStr);
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    Date d = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String time = sdf.format(d);
                    System.out.println(time + ":备份日志一次！");
                }
            }, firstTime, 1000 * 5);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

    从初始时间开始打印定时任务，没5s打印一次

生产者和消费者模式

方法名	作用
void wait()	让活动在当前对象的线程无限等待（释放之前占有的锁）
void notify()	唤醒当前对象正在等待的线程（只提示唤醒，不会释放锁）
void notifyAll()	唤醒当前对象全部正在等待的线程（只提示唤醒，不会释放锁）

•  wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方法是 Object类中自带 的。
• wait方法和notify方法不是通过线程对象调用，不是这样的：t.wait()，也不是这样的：t.notify()…不对。而是 Object o = new Object();  o.wait();
• o.wait()表示：
  ​ 让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。
  ​ o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。

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

模拟生产与消费者需求

仓库采用list集合list集合中假设只能存储一个元素 1个元素就代表仓库满了 如果list集合中的元素为0，就表示仓库空了 保证list集合永远都是最多存储一个元素 必须做到这种效果：生成一个消费一个

package 多线程.守护线程;


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

public class ProductAndComsumer {
    public static void main(String[] args) {
        //创建仓库对象
        List list  = new ArrayList();
        //创建两个线程对象

        //一个是生产者线程
        Thread thread1 = new Thread(new Procuder(list));
        //一个是消费者线程
        Thread thread2 = new Thread(new Consumer(list));

        thread1.setName("生产者线程");
        thread2.setName("消费者线程");
        thread1.start();
        thread2.start();
    }
}
//生产线程
class Procuder implements Runnable{
    //共享的仓库
    private List list;

    public Procuder() {
    }

    public Procuder(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //一直生产
        while(true){
            synchronized (list){
                if(list.size() > 0){
                    //当前线程进入等待状态
                    try {
                        list.wait();//当前线程进入等待状态，并且释放procuder之前占有list集合的锁
                    } 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() {
    }

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        //一直消费
        while(true){
            synchronized (list){
                if(list.size() == 0){
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序执行到这里说明仓库中有数据，进行消费
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "---->" + obj);
                //唤醒生产者生产
                list.notify();
            }
        }
    }
}