java守护线程_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框架，

这个框架只要进行简单的配置，就可以完成定时器的任务。

packagecom.bjpowernode.java.thread;importjava.text.SimpleDateFormat;importjava.util.Date;importjava.util.Timer;importjava.util.TimerTask;/*使用定时器指定定时任务。*/

public classTimerTest {public static void main(String[] args) throwsException {//创建定时器对象

Timer timer = newTimer();//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(newTimerTask(){

@Overridepublic voidrun() {//code....

}

} , firstTime,1000 * 10);

}

}//编写一个定时任务类//假设这是一个记录日志的定时任务

class LogTimerTask extendsTimerTask {

@Overridepublic voidrun() {//编写你需要执行的任务就行了。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String strTime= sdf.format(newDate());

System.out.println(strTime+ ":成功完成了一次数据备份！");

}

}

3、实现线程的第三种方式：实现Callable接口。(JDK8新特性。)

这种方式实现的线程可以获取线程的返回值。

之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回void。

思考：

系统委派一个线程去执行一个任务，该线程执行完任务之后，可能

会有一个执行结果，我们怎么能拿到这个执行结果呢？

使用第三种方式：实现Callable接口方式。

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

/*实现线程的第三种方式：

实现Callable接口

这种方式的优点：可以获取到线程的执行结果。

这种方式的缺点：效率比较低，在获取t线程执行结果的时候，当前线程受阻塞，效率较低。*/

public classThreadTest15 {public static void main(String[] args) throwsException {//第一步：创建一个“未来任务类”对象。//参数非常重要，需要给一个Callable接口实现类对象。

FutureTask task = new FutureTask(newCallable() {

@Overridepublic 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 = newThread(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对象上处于等待的所有线程。

生产者和消费者模式

packagecom.bjpowernode.java.thread;importjava.util.ArrayList;importjava.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 classThreadTest16 {public static voidmain(String[] args) {//创建1个仓库对象，共享的。

List list = newArrayList();//创建两个线程对象//生产者线程

Thread t1 = new Thread(newProducer(list));//消费者线程

Thread t2 = new Thread(newConsumer(list));

t1.setName("生产者线程");

t2.setName("消费者线程");

t1.start();

t2.start();

}

}//生产线程

class Producer implementsRunnable {//仓库

privateList list;publicProducer(List list) {this.list =list;

}

@Overridepublic voidrun() {//一直生产(使用死循环来模拟一直生产)

while(true){//给仓库对象list加锁。

synchronized(list){if(list.size() > 0){ //大于0，说明仓库中已经有1个元素了。

try{//当前线程进入等待状态，并且释放Producer之前占有的list集合的锁。

list.wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

}//程序能够执行到这里说明仓库是空的，可以生产

Object obj = newObject();

list.add(obj);

System.out.println(Thread.currentThread().getName()+ "--->" +obj);//唤醒消费者进行消费

list.notifyAll();

}

}

}

}//消费线程

class Consumer implementsRunnable {//仓库

privateList list;publicConsumer(List list) {this.list =list;

}

@Overridepublic voidrun() {//一直消费

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();

}

}

}

}

交替打印 数字