当前位置：首页 > news >正文

网站的设计方法有哪些内容百度一下官方网

news 2025/8/6 0:49:08

网站的设计方法有哪些内容,百度一下官方网,免费logo设计在线生成器官网,做兼职的网站都有哪些工作定时器概念当我们不需要某个线程立刻执行，而是在指定时间点或指定时间段之后执行，假如我们要定期清理数据库里的一些信息时，如果每次都手动清理的话就太麻烦，所以就可以使用定时器。定时器就可以比作一个闹钟，可以让…

定时器概念

当我们不需要某个线程立刻执行，而是在指定时间点或指定时间段之后执行，假如我们要定期清理数据库里的一些信息时，如果每次都手动清理的话就太麻烦，所以就可以使用定时器。定时器就可以比作一个闹钟，可以让我们的线程在指定的时间执行，还可以指定时间循环执行。

标准库中的定时器

在标准库中提供了一个Timer类，Timer是一种定时器工具，可以让一个线程在指定时间一次或反复执行。

Timer的构造方法

Timer()
Timer(String name)	设定定时器的名字
Timer(boolean isDeamon)	是否将定时器作为守护线程
Timer(String name,boolean isDeamon)	设定定时器名字，并设定是否为守护线程执行

非守护线程：JVM会等待所有非守护线程执行完毕之后才会退出

守护线程：JVM不会等待守护线程执行完毕，当没有非守护线程在执行JVM就会关闭，即使有守护线程在执行

TimerTask是一个抽象类，表示的是一个可以被timer执行的任务，任务的具体实现在TimerTask的run方法里。

schedule方法是Timer中的核心方法用来执行TimerTask的任务并设定时间，具体的参数有以下几种

schedule(TimerTask task，Date time);

在time时间(时间点)执行任务一次

schedule(TimerTask task，long delay);

在delay时间后执行任务一次(单位毫秒)

schedule(TimerTask task，Date firstTime，long period);

在firstTime时间点执行一次任务，在定期的period时间段后反复执行(如果时间点是已经过去的时间就会立刻执行)

schedule(TimerTask task，long delay，long period);

在延迟delay毫秒后执行任务一次，在定期的period时间段后反复执行(如果时间点是已经过去的时间就会立刻执行)

定时器的使用

在指定时间段后执行

public static void main(String[] args) {Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行//给定时器安排一个任务，xxxms后执行timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("开始执行定时器任务");}},1000);System.out.println("执行任务");}

主线程执行schedule方法的时候，就是把这个任务放到timer对象中了，与此同时timer里头也有一个线程叫做“扫描线程”，一旦时间到扫描线程就会执行刚才安排的任务了，仔细观察可以发现，整个线程，其实没有结束，就是因为Timer内部的线程阻止了进程的结束，而且在timer里是可以安排多个任务的，这些任务会按照时间顺序执行。(也就是我们刚刚说过的非守护线程，给timer设置成守护线程，此时整个线程就会结束了)

在指定时间点执行

 public static void main(String[] args) {Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行//给定时器安排一个任务，xxxms后执行//获取5秒后的一个时间点：doTimeCalendar cal=Calendar.getInstance();cal.add(Calendar.SECOND,5);Date doTime=cal.getTime();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("开始执行定时器任务" + new Date());}},doTime);System.out.println(new Date());}

在指定时间段后定期循环执行

public static void main(String[] args) {Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行//给定时器安排一个任务，xxxms后执行timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("开始执行定时器任务" + new Date());}},2000,1000);System.out.println(new Date());}

在指定时间点后定期循环执行

public static void main(String[] args) {Timer timer = new Timer();//对象被创建时，线程也跟着被创建，后续timer执行任务都是由这个线程执行//给定时器安排一个任务，xxxms后执行//获取5秒后的一个时间点：doTimeCalendar cal=Calendar.getInstance();cal.add(Calendar.SECOND,5);Date doTime=cal.getTime();timer.schedule(new TimerTask() {@Overridepublic void run() {System.out.println("开始执行定时器任务" + new Date());}},doTime,1000);System.out.println(new Date());}

定时器的实现

这里我们来简单实现一个定时器

初步分析

Timer中要有一个扫描线程线程，扫描任务是否到时间可以执行了
需要一种数据结构来储存这些任务
还需要创建一个类来描述一个任务，要包含内容和时间

先来考虑使用什么数据结构来储存任务，既然Timer中的任务是从时间最小的开始执行，那么我们就可以使用优先级队列！！

实现

MyTimerTask

一个执行的任务至少要包含任务内容和执行的时间，这里我用的是绝对时间当要判断一个线程是否需要执行时，先获取一个当前的时间戳(2:30)，在获取任务要执行的时间戳(2:35)，最后对比两个时间戳就知道现在是否要执行任务。

但是我们刚刚有提到，要使用优先级队列来存储任务，所以我们还要有一个任务的比较规则（我们要让队列知道该怎么比）

所以完整的代码如下：

class MytimerTask implements Comparable<MytimerTask>{//要执行的任务private Runnable runnable;//要执行任务的绝对时间private long time;public MytimerTask(Runnable runnable,long time){this.runnable = runnable;//此处this.time是应该开始执行任务的时间，time是多久后执行this.time = System.currentTimeMillis() + time;}//任务的比较规则@Overridepublic int compareTo(MytimerTask o) {return (int)(this.time - o.time);}public Runnable getRunnable() {return runnable;}public long getTime() {return this.time;}
}

MyTimer

定义一个优先级队列，实现schedule方法

 private PriorityQueue<MytimerTask> queue = new PriorityQueue<>();public void schedule(Runnable runnable,long time){  //向队列里插入一个任务，以及过多久后执行该任务queue.offer(new MytimerTask(runnable,time));}

实现扫描线程

private Object locker = new Object();public MyTimer(){//创建一个扫描线程Thread t = new Thread(() -> {//扫描线程，需要不停扫描队首元素，看是否到达时间while (true){try {synchronized (locker){//使用while是为了在wait被唤醒的时候，再次确认一下条件while (queue.isEmpty()){//这里的wait，需要有另外线程唤醒//添加新的任务就应该唤醒locker.wait();}MytimerTask task = queue.peek();//比较一下当前的队首元素（就是最近一个要执行的任务）是否可以执行了long curtime = System.currentTimeMillis();if(curtime >= task.getTime()){//当时间到达任务时间，就可以执行任务了task.getRunnable().run();//任务执行完之后在队列中删除queue.poll();}else {//还没到任务时间，暂时不执行任务locker.wait(task.getTime() - curtime);}}}catch (InterruptedException e){e.printStackTrace();break;}}});t.start();}

因为我们需要不断的判断队列里的线程是否到达时间，所以使用while循环

因为当前可能会是在多线程下使用，所以我们要保证线程安全问题，使用synchronization来进行加锁

如果队列为空的话，就需要阻塞等待直到有新的任务加入，所以schedule方法应该这样实现

public void schedule(Runnable runnable,long time){synchronized (locker){//向队列里插入一个任务，以及过多久后执行该任务queue.offer(new MytimerTask(runnable,time));//当队列为空时，此时插入一个任务之后唤醒waitlocker.notify();}}

这里还有一个问题，因为while的执行速度很快，如果让他一直不断的循环，就会造成忙等问题(在消耗cpu资源但是并没有实质性的用处)，假如最近一个要执行的任务是十分钟之后，那么从现在开始的十分钟之内，while是没有执行的必要的，不停的循环只会浪费资源。

所以我们可以进行判断，当还没有到最近一个任务执行时间时，我们就让线程阻塞，阻塞的时间就是现在到最近一个要执行的任务的时间，这样就可以解决忙等问题。

那么可不可以使用sleep呢？当然是不行的。

可能在等待过程中主线程调用schedule又添加一个新任务，这个任务比其他任务执行的时间更早，使用wait就恰好可以利用刚才schedule中的notify来唤醒这里的wait，让循环再执行一遍，重新拿到队首执行时间最少的任务

之所以刚刚的代码使用的是PriorityQueue而不是PriorityBlockingQueue，其实就是因为要处理两个wait的地方，使用阻塞版本的优先级队列，不方便实现。

完整代码如下

class MytimerTask implements Comparable<MytimerTask>{//要执行的任务private Runnable runnable;//要执行任务的绝对时间private long time;public MytimerTask(Runnable runnable,long time){this.runnable = runnable;//此处this.time是应该开始执行任务的时间，time是多久后执行this.time = System.currentTimeMillis() + time;}//任务的比较规则@Overridepublic int compareTo(MytimerTask o) {return (int)(this.time - o.time);}public Runnable getRunnable() {return runnable;}public long getTime() {return this.time;}
}
//自己的定时器
class MyTimer{private PriorityQueue<MytimerTask> queue = new PriorityQueue<>();public void schedule(Runnable runnable,long time){synchronized (locker){//向队列里插入一个任务，以及过多久后执行该任务queue.offer(new MytimerTask(runnable,time));//当队列为空时，此时插入一个任务之后唤醒waitlocker.notify();}}private Object locker = new Object();public MyTimer(){//创建一个扫描线程Thread t = new Thread(() -> {//扫描线程，需要不停扫描队首元素，看是否到达时间while (true){//开始进行一次扫描try {synchronized (locker){//使用while是为了在wait被唤醒的时候，再次确认一下条件while (queue.isEmpty()){//这里的wait，需要有另外线程唤醒//添加新的任务就应该唤醒locker.wait();}MytimerTask task = queue.peek();//比较一下当前的队首元素（就是最近一个要执行的任务）是否可以执行了long curtime = System.currentTimeMillis();if(curtime >= task.getTime()){//当时间到达任务时间，就可以执行任务了task.getRunnable().run();//任务执行完之后在队列中删除queue.poll();}else {//还没到任务时间，暂时不执行任务locker.wait(task.getTime() - curtime);}}}catch (InterruptedException e){e.printStackTrace();break;}}});t.start();}
}

到这里一个简单的定时器就完成了

测试

  public static void main(String[] args) {MyTimer timer = new MyTimer();timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("3000" + new Date());}},3000);timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("2000"+ new Date());}},2000);timer.schedule(new Runnable() {@Overridepublic void run() {System.out.println("1000"+ new Date());}},1000);System.out.println("启动程序");}