Java 守护线程及其它
线程这块还有那些内容呢？列举一下
守护线程
定时器
实现线程的第三种方式：FutureTask方式，实现Callable接口。（JDK8新特性。）
关于Object类中的wait和notify方法。（生产者和消费者模式！）
1、守护线程
java语言中线程分为两大类：
一类是：用户线程
一类是：守护线程（后台线程）
其中具有代表性的就是：垃圾回收线程（守护线程）。
守护线程的特点：
一般守护线程是一个死循环，所有的用户线程只要结束，守护线程自动结束。
注意：主线程main方法是一个用户线程。
守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份。
这个需要使用到定时器，并且我们可以将定时器设置为守护线程。
一直在那里看着，没到00:00的时候就备份一次。所有的用户线程
如果结束了，守护线程自动退出，没有必要进行数据备份了。
t.setDaemon(true); -- 设置成守护线程
2、定时器
定时器的作用：
间隔特定的时间，执行特定的程序。
每周要进行银行账户的总账操作。
每天要进行数据的备份操作。
在实际的开发中，每隔多久执行一段特定的程序，这种需求是很常见的，
那么在java中其实可以采用多种方式实现：
可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行
任务。这种方式是最原始的定时器。（比较low）
在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。
不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持
定时任务的。
在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，
这个框架只要进行简单的配置，就可以完成定时器的任务。
package com.bjpowernode.java.thread; 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 Exception { // 创建定时器对象 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("2020-03-14 09:34:30"); //timer.schedule(new LogTimerTask() , firstTime, 1000 * 10); // 每年执行一次。 //timer.schedule(new LogTimerTask() , firstTime, 1000 * 60 * 60 * 24 * 365); //匿名内部类方式 timer.schedule(new TimerTask(){ @Override public void run() { // code.... } } , firstTime, 1000 * 10); } } // 编写一个定时任务类 // 假设这是一个记录日志的定时任务 class LogTimerTask extends TimerTask { @Override public void run() { // 编写你需要执行的任务就行了。 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String strTime = sdf.format(new Date()); System.out.println(strTime + ":成功完成了一次数据备份！"); } }
3、实现线程的第三种方式：实现Callable接口。（JDK8新特性。）
这种方式实现的线程可以获取线程的返回值。
之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。
思考：
系统委派一个线程去执行一个任务，该线程执行完任务之后，可能
会有一个执行结果，我们怎么能拿到这个执行结果呢？
使用第三种方式：实现Callable接口方式。
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; //自动装箱(300结果变成Integer) } }); // 创建线程对象 Thread t = new Thread(task); // 启动线程 t.start(); // 这里是main方法，这是在主线程中。 // 在主线程中，怎么获取t线程的返回结果？ // get()方法的执行会导致“当前线程阻塞” Object obj = task.get(); System.out.println("线程执行结果:" + obj); // main方法这里的程序要想执行必须等待get()方法的结束 // 而get()方法可能需要很久。因为get()方法是为了拿另一个线程的执行结果 // 另一个线程执行是需要时间的。 System.out.println("hello world!"); } }
4、关于Object类中的wait和notify方法。（生产者和消费者模式！）
第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象
都有的方法，因为这两个方式是Object类中自带的。
wait方法和notify方法不是通过线程对象调用，
不是这样的：t.wait()，也不是这样的：t.notify()..不对。
第二：wait()方法作用？
Object o = new Object();
o.wait();
表示：
让正在o对象上活动的线程进入等待状态，无期限等待，
直到被唤醒为止。
o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。
第三：notify()方法作用？
Object o = new Object();
o.notify();
表示：
唤醒正在o对象上等待的线程。
还有一个notifyAll()方法：
这个方法是唤醒o对象上处于等待的所有线程。
生产者和消费者模式
package com.bjpowernode.java.thread; import java.util.ArrayList; import java.util.List; /* 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、模拟这样一个需求： 仓库我们采用List集合。 List集合中假设只能存储1个元素。 1个元素就表示仓库满了。 如果List集合中元素个数是0，就表示仓库空了。 保证List集合中永远都是最多存储1个元素。 必须做到这种效果：生产1个消费1个。 */ public class ThreadTest16 { public static void main(String[] args) { // 创建1个仓库对象，共享的。 List list = new ArrayList(); // 创建两个线程对象 // 生产者线程 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; } @Override public void run() { // 一直生产（使用死循环来模拟一直生产） while(true){ // 给仓库对象list加锁。 synchronized (list){ if(list.size() > 0){ // 大于0，说明仓库中已经有1个元素了。 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.notifyAll(); } } } } // 消费线程 class Consumer implements Runnable { // 仓库 private List list; public Consumer(List list) { this.list = list; } @Override 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.notifyAll(); } } } }
交替打印 数字
