其他分享
首页 > 其他分享> > 111

111

作者:互联网

线程剩余内容

```java

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

 

# day34课堂笔记

### 4.11守护线程

```java
守护线程
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
定时器的作用:
间隔特定的时间,执行特定的程序
每周要进行银行账户的总账操作
每天要进行数据的备份操作

在实际的开发中,每隔多久执行一段特定的程序,这种需求是很常见的
在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 实现线程的第三种方式

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

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


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

标签:定时器,java,线程,new,111,public,守护
来源: https://www.cnblogs.com/jingxian666/p/16564316.html