1112

线程剩余内容

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

day34课堂笔记

4.11守护线程

守护线程
	java语言中线程分为两大类：
		一类是：用户线程
		一类是：守护线程（后台线程）
		其中具有代码性的就是：垃圾回收线程（守护线程）
	守护线程的特点：
		一般守护线程是一个死循环，所有的用户线程只要结束
		守护线程自动结束。
	注意：主线程main方法是个用户线程
	守护线程用在什么地方呢？
		每天00:00的时候系统数据自动备份
		这个需要使用到定时器，并且我们可以将定时器设置成守护线程
		一直在那里看着，每到00:00的时候就备份一次。
		如果结束了，守护线程自动退出，没有必要进行数据备份了。


package com.bjpowernode.java.thread;

/*
守护线程
 */
public class ThreadTest14 {
    public static void main(String[] args) {
        Thread t = new BakDataThread();
        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 BakDataThread 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();
            }
        }
    }
}

4.12 定时器

定时器的作用：
	间隔特定的时间，执行特定的程序
	每周要进行银行账户的总账操作
	每天要进行数据的备份操作
	
	在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的	
	在java中其实可以采用多种方式实现：
		可以使用sleep方法，睡眠，设置睡眠时间，每到这个时间点醒过来执行任务，这种方式是最原始的定时器。（比较low）
		
		在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过这种方式在目前的开发中也很少用，因为现在有很多的高级框架都是支持定时任务的。
		
		在实际的开发中，目前使用较多的是Spring框架提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务


package com.bjpowernode.java.thread;

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

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

        // 指定定时任务
        // timer.schedule(定时任务，第一次执行时间，间隔多久执行一次）;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2022-07-31 15:16:00");
        // timer.schedule(new LogTimerTask(), firstTime, 1000 * 10);

        // 采用匿名内部类的方式
        timer.schedule(new TimerTask(){
            @Override
            public void run() {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
                String strTime = sdf.format(new Date());
                System.out.println(strTime + ": 成功完成了一次数据备份！");
            }
        }, firstTime, 1000 * 10);
    }
}

// 编写一个定时任务类
// 假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask {

    @Override
    public void run() {
        // 编写你需要执行的任务就行了
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String strTime = sdf.format(new Date());
        System.out.println(strTime + ": 成功完成了一次数据备份！");
    }
}

4.13 实现线程的第三种方式

这种方式实现的线程可以获取线程的返回值
之前讲解的那两种方式是无法获取线程返回值的

思考：
	系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，我们怎么能拿到这个执行结果呢？


package com.bjpowernode.java.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;  // JUC包下的，属于java的并发包，老JDK中没有这个包，新特性

/*
实现线程的第三种方式
    实现Callable接口
    这种方式的优点：可以获取到线程的执行结果
    这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低
 */
public class ThreadTest15 {
    public static void main(String[] args) throws Exception{

        // 第一步：创建一个“未来任务类”对象
        // 参数非常重要，需要给一个Callable接口的实现类对象。
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {  // call方法就相当于run方法，只不过这个有返回值
                // 线程执行一个任务，执行之后可能会有一个执行结果
                // 模拟执行
                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;  // 自动装箱
            }
        });

        // 创建线程对象
        Thread t = new Thread(task);

        // 启动线程
        t.start();

        // 这里是main方法，这是在主线程中
        // 在主线程中，怎么获取线程的返回结果
        // get()方法的执行会导致当前线程阻塞
        Object obj = task.get();
        System.out.println("线程执行结果: " + obj);

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

4.14