JavaSE进阶 | 深入理解多线程（守护线程、定时器、实现线程同步的第三种方式、生产者和消费者）
目录
线程内容补充
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运行完，备份数据的线程也会自动终止
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中其实可以采用多种方式实现：
第一种方式：可以使用sleep方法睡眠，设置睡眠时间，每到这个时间点醒来，执行任务，这种方式是最原始的定时器。第二种方式：在java的类库中已经写好了一个定时器：java.util.Timer，可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
第三种方式：在实际的开发中，目前使用较多的是Spring框架中提供的SpringTask框架，这个框架只要进行简单的配置，就可以完成定时器的任务。
（3）核心：继承TimerTask类，创建Timer对象，调用schedule方法
第一步：编写定时任务类继承TimerTask类，重写run方法，在里面编写具体的定时任务逻辑
第二步：创建Timer对象，调用Timer对象的schedlue方法，里面有三个参数：
schedule(定时任务，第一次执行时间，间隔多久执行一次)
①第一个参数是继承TimerTask类的定时任务类；
②第二个参数是Date类型，第一次执行时间或者说从何时开始第一次执行；
③第三个参数是间隔多久执行一次，单位是毫秒数；
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("yyyy-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("yyyy-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）这种方式执行效率较低，在获取返回值时有可能造成当前线程阻塞！
（4）实现步骤：
第一步：创建一个类实现Callable接口，重写里面的call()方法；call方法就相当于前面说的run方法，只不过call方法是有返回值的Object；run方法没有返回值是void；
第二步：先创建实现Callable接口的实现类；
第三步：在创建一个未来任务类FutureTask，调用有参构造方法，参数就是上面的实现类；
第四步：创建Thread类，把未来任务类FutureTask对象传进去；最终调用start方法启动线程
（5）小总结：
①从下面代码可以看出确实可以拿到返回值，通过调用未来任务类FutureTask的get方法；默认返回的一个Object类型，包括我们重写call方法时返回的也是一个Object类型；但是我们也可以使用泛型机制，返回指定的数据类型。
②在获取数据可能会导致当前线程阻塞的问题，我们要想拿到call方法的返回值，必须等到call方法结束，return我们才可以拿到；在return之前，当前线程就会处于阻塞状态！
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()方法作用
表示：让正在o对象上活动的线程进入等待状态，无期限等待，直到被唤醒为止。o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。
Object o = new Object();
o.wait();（4）notify()方法作用
表示：唤醒正在o对象上等待的线程。还有一个notifyAll()方法：这个方法是唤醒o对象上处于等待的所有线程。
Object o = new Object();
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个；
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();
}
}
}
}相关文章
- java多线程并发之旅-14-lock free queue 无锁队列[通俗易懂]
- c++多线程重点难点（三）Mutex
- C#多线程同步事件及等待句柄
- 3-多线程安全问题，线程同步
- 多线程(四)-线程同步
- 多线程&并发篇（1024节日快乐）
- 多线程引发的惨案直接把年终给干没了
- java同步机制解决多线程安全问题
- Java批量更新太慢？多线程+List分段完美解决！
- Java Socket多线程编程示例详解编程语言
- java基础多线程之共享数据详解编程语言
- 多线程同步中sleep与wait区别详解编程语言
- Java多线程编程——进阶篇一详解编程语言
- MySQL 多线程实现同步机制（mysql多线程同步）
- 多线程在Linux系统下的应用（多线程linux）
- 突破性的技术——开启多线程Oracle之旅（多线程读oracle）
- Linux多线程解决同步问题（linux线程同步方式）
- 如何实现多线程安全的同时共用一个Redis（多线程共用一个redis）
- java多线程编程之join方法的使用示例
- java多线程编程之为什么要进行数据同步
- android开发教程之handle实现多线程和异步处理
- Python中多线程及程序锁浅析