Java:如何正确使用Timer【java定时器的使用(Timer) 】

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/yw_1207/article/details/79468333

哎,以前还是太年轻,这样就好了:

public class SandTimer {
    public void timerRun() {
        // 一天的毫秒数
        long daySpan = 24 * 60 * 60 * 1000;
        // 规定的每天时间15:33:30运行
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd 09:16:00");
        // 首次运行时间
        try {
            Date startTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(sdf.format(new Date()));
            // 如果今天的已经过了 首次运行时间就改为明天
            if (System.currentTimeMillis() > startTime.getTime()){
                startTime = new Date(startTime.getTime() + daySpan);
            }
            Timer t = new Timer();
            TimerTask task = new TimerTask() {
                @Override
                public void run() {
                    System.out.print("定时器执行");
                }
            };
            // 以每24小时执行一次
            t.schedule(task, startTime, daySpan);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        new SandTimer().timerRun();
    }

----------------------------------------------------------------------下面是以前写的------------------------------------------------------------------------------

在需要按时间计划执行简单任务的情况下,Timer是最常被使用到的工具类。使用Timer来调度TimerTask的实现者来执行任务,有两种方式,一种是使任务在指定时间被执行一次,另一种是从某一指定时间开始周期性地执行任务。
 
下面是一个简单的Timer例子,它每隔10秒钟执行一次特定操作doWork。
Timer timer = new Timer();
                        TimerTask  task = new TimerTask (){
                        public void run() {
                             doWork();
                           }
};
              timer.schedule (task, 10000L, 10000L);
可以看到,具体的任务由TimerTask的子类实现,Timer负责管理、执行TimerTask。
 
Timer 的使用
在不同的场景下,需要使用不同的Timer接口。如上所说,主要区分两种情况
1) 在指定时间执行任务,只执行一次
-          public void schedule(TimerTask task, long delay)
-          public void schedule(TimerTask task, Date time)
 
2)从指定时间开始,周期性地重复执行,直到任务被cancel掉。其中又分两种类型:
2.1) 一种是按上一次任务执行的时间为依据,计算本次执行时间,可以称为相对时间法。比如,如果第一次任务是1分10秒执行的,周期为5秒,因系统繁忙(比如垃 圾回收、虚拟内存切换),1分15秒没有得到机会执行,直到1分16秒才有机会执行第二次任务,那么第3次的执行时间将是1分21秒,偏移了1秒。
-          public void schedule(TimerTask task, long delay, long period)
-          public void schedule(TimerTask task, Date firstTime, long period)
 
2.2) 另一种是绝对时间法,以用户设计的起始时间为基准,第n次执行时间为“起始时间+n*周期时间”。比如,在上面的情况下,虽然因为系统繁忙,第二执行时间被推后1秒,但第3次的时间点仍然应该是1分20秒。
-          public void scheduleAtFixedRate(TimerTask task, long delay, long period)
-          public void scheduleAtFixedRate(TimerTask task, Date firstTime,                                    long period)
 
相 对时间法,关注于满足短时间内的执行间隔,绝对时间法,则更关注在一个长时间范围内,任务被执行的次数。如果我们要编写一个程序,用timer控制文档编 辑器中提示光标的闪烁,用哪种更合适? 当然是相对时间法。如果改用绝对时间法,当从系统繁忙状态恢复后,光标会快速连续闪烁多次,以弥补回在系统繁忙期间没有被执行的任务,这样的情况会用户来 说比较难以接受。又如,每10分钟检查一次新邮件的到来,也适合于使用相对时间法。
Timer timer = new Timer();
                        TimerTask  task = new TimerTask (){
                         public void run() {
                                displayCursor();
                           }
};
              timer.schedule (task, 1000L, 1000L); //每秒闪烁一次光标
 
作为对比,我们来考虑一种绝对时间法的应用场景——倒数任务,比如,要求在10秒内做倒数计时,每秒做一次doworkPerSecond操作,10秒结束时做一次doworkEnd操作,然后结束任务。
Timer timer = new Timer();
                        TimerTask  task = new TimerTask (){
                              private int count=10;
                              public void run() {
                                   if(count>0){
                                      doWorkPerSecond();
                                     count--;
                            }else{
                               doWorkEnd();
                               cancel();
                             }
                           }
};
                        timer. scheduleAtFixedRate (task, 1000L, 1000L);
Timer及相关类的内部实现
Timer的内部会启动一个线程TimerThread。即使有多个任务被加入这个Timer,它始终只有一个线程来管理这些任务。
-          TimerThread是Thread的子类。加入Timer的所有任务都会被最终放入TimerThread所管理的TaskQueue中。 TimerThread会不断查看TaskQueue中的任务,取出当前时刻应该被执行的任务执行之,并且会重新计算该任务的下一次执行时间,重新放入 TaskQueue。直到所有任务执行完毕(单次任务)或者被cancel(重复执行的任务),该线程才会结束。
-          TaskQueue,由数组实现的二叉堆,堆的排序是以任务的下一次执行时间为依据的。二叉堆的使用使得TimerThread以简洁高效的方式快速找到 当前时刻需要执行的TimerTask,因为,堆排序的特性是保证最小(或者最大)值位于堆叠顶端,在这里,queue[1]始终是下次执行时间 (nextExecutionTime)最小的,即应该最先被执行的任务
 
比如,同一个timer管理两个任务task1和task2
timer.schedule (task1, 4000L, 10000L);
timer. scheduleAtFixedRate (task2, 2000L, 15000L);
则,TaskQueue 中会有两个任务:task1和task2。task2会排在头部queue[1],当task2执行时间到,task2被执行,同时修改其 nextExecutionTime =当前的nextExecutionTime +15000L(绝对时间法)并重新在二叉堆中排序。排序后,task1被放到头部。当task1执行时间到,task1被执行,并修改其 nextExecutionTime =当前时间+10000L,然后重新在二叉堆中对其排序………
 
一个例子 
当收到客户端请求时,服务端生成一个Response对象。服务端希望客户端访问该对象的间隔时间不能超过20秒,否则,服务端认为客户端已经异常关闭或者网络异常,此时销毁掉该对象并打印错误日志。每次访问都会重新开始计时。
 
class Response{
private TimerTask  timeout;
            public void init(){
         ………
Timer timer = new Timer();
timeout = new TimeOutTask();
                        timer.schedule (timeout, 20000L);
}
 
public void invoke(){
    timeout.cancel();//取消当前的timeout任务
; ….
   timeout = new TimeOutTask();
                           timer.schedule (timeout, 20000L);//重新开始计时
}
 
void destroy(){
   ……..
}
 
class TimeOutTask extends TimerTask{
           public void run() {
TraceTool.error(“Time out, destroy the Response object.”);
destroy();
                           }
}
}
 
因为Timer不支持对任务重置计时,所以此处采取了先cancel当前的任务再重新加入新任务来达到重置计时的目的。注意,对一个已经cancel的任务,不能通过schedule重新加入Timer中执行。TimerTask的状态机如下:
 

一个新生成的TimerTask其状态为VIRGIN,Timer只接受状态为VIRGIN的任务,否则会有IllegalStateException异常抛出。
调用任务的cancel方法,该任务就转入CANCELLED状态,并很快从TaskQueue中删除。对单次执行的任务,一旦执行结束,该任务也会从中删除。这意味着TimerTask将不再被timer所执行了。

 

 

 

Java定时器的使用(Timer

1、在应用开发中,经常需要一些周期性的操作,比如每5分钟执行某一操作等。

对于这样的操作最方便、高效的实现方式就是使用java.util.Timer工具类。

private java.util.Timer timer;

timer = new Timer(true);

timer.schedule(

new java.util.TimerTask() { public void run()

{ //server.checkNewMail(); 要操作的方法} }, 0, 5*60*1000);

第一个参数是要操作的方法,第二个参数是要设定延迟的时间,第三个参

数是周期的设定,每隔多长时间执行该操作。

使用这几行代码之后,Timer本身会每隔5分钟调用一遍

server.checkNewMail()方法,不需要自己启动线程。Timer本身也是多线程同

步的,多个线程可以共用一个Timer,不需要外部的同步代码。

2

(1)Timer.schedule(TimerTask task,Date time)安排在制定的时间执行指定的

任务。

(2)Timer.schedule(TimerTask task,Date firstTime ,long period)安排指定

的任务在指定的时间开始进行重复的固定延迟执行.

(3)Timer.schedule(TimerTask task,long delay)安排在指定延迟后执行指定的

任务.

(4)Timer.schedule(TimerTask task,long delay,long period)安排指定的任务

从指定的延迟后开始进行重复的固定延迟执行.

(5)Timer.scheduleAtFixedRate(TimerTask task,Date firstTime,long period)

安排指定的任务在指定的时间开始进行重复的固定速率执行.

(6)Timer.scheduleAtFixedRate(TimerTask task,long delay,long period)

排指定的任务在指定的延迟后开始进行重复的固定速率执行.

Java Timer API进行时间调度开发的相关注意点

java.util这个包中可以找到TimerTimerTask这两个类。Timer直接从Object

继承,它相当于一个计时器,能够用它来指定某个时间来执行一项任务,或者

每隔一定时间间隔反复执行同一个任务。创建一个Timer后,就会生成一个线程

在背后运行,来控制任务的执行。而TimerTask就是用来实现某项任务的类,

它实现了Runnable接口,因此相当于一个线程。

如何实现自己的任务调度?

1、继承TimerTask,注意TimerTask是实现Runnable接口的,因此只要重载run()

方法即可。

2、创建Timer对象,调用schedule()方法。

相关注意点分析:

1、任务调度要优先考虑实时保证

由于Java的天性,并且在开发JDK的过程中要考虑到不同平台,而不同平台的

线程调度机制是不同的,因此各种平台下JVM的线程调度机制也是不一致的。

从而Timer不能保证任务在所指定的时间内执行。另外由于TimerTask是实现

Runnable接口的,在TimerTask被放进线程队列睡眠一段时间(wait)之后,

当到了指定的该唤起该TimerTask时,由于执行的确切时机取决于JVM的调度策

略和当前还有多少线程在等待CPU处理。因此就不能保证任务在所指定的时间

内执行。通常在如下两种情况下导致任务延迟执行:

1)、有大量线程在等待执行

2)、GC机制的影响导致延迟

这也是为什么在Timer API中存在两组调度方法的原因。即:

1)、schedule()

用固定延迟调度。使用本方法时,在任务执行中的每一个延迟会传播到后续的任

务的执行。

2)、scheduleAsFixedRate()

用固定比率调度。使用本方法时,所有后续执行根据初始执行的时间进行调度,

从而希望减小延迟。

具体使用哪一个方法取决于哪些参数对你的程序或系统更重要。

2、每个Timer对象要在后台启动一个线程。这种性质在一些托管的环境下不推

荐使用,比如在应用服务器中。因为这些线程不在容器的控制范围之内了。

具体Java API中的Timer类和TimerTask类的描述如下:

java.util

Timer

java.lang.Object

java.util.Timer

public class Timer

extends Object

一种线程设施,用于安排以后在后台线程中执行的任务。可安排任务执行一次,

或者定期重复执行。

与每个Timer对象相对应的是单个后台线程,用于顺序地执行所有计时器任务。

计时器任务应该迅速完成。如果完成某个计时器任务的时间太长,那么它会“独

占”计时器的任务执行线程。因此,这就可能延迟后续任务的执行,而这些任务

就可能“堆在一起”,并且在上述令人讨厌的任务最终完成时才能够被快速连续

地执行。

Timer对象最后的引用完成后,并且所有未处理的任务都已执行完成后,计

时器的任务执行线程会正常终止(并且成为垃圾回收的对象)。但是这可能要很

长时间后才发生。默认情况下,任务执行线程并不作为守护线程来运行,所以

它能够阻止应用程序终止。如果调用方想要快速终止计时器的任务执行线程,那

么调用方应该调用计时器的cancel方法。

如果意外终止了计时器的任务执行线程,例如调用了它的stop方法,那么所有

以后对该计时器安排任务的尝试都将导致IllegalStateException,就好像调用

了计时器的cancel方法一样。

此类是线程安全的:多个线程可以共享单个Timer对象而无需进行外部同步。

此类提供实时保证:它使用Object.wait(long)方法来安排任务。

实现注意事项:此类可扩展到大量同时安排的任务(存在数千个都没有问题)。

在内部,它使用二进制堆来表示其任务队列,所以安排任务的开销是O(log n)

其中是同时安排的任务数。

实现注意事项:所有构造方法都启动计时器线程。

从以下版本开始:

1.3

另请参见:

TimerTask,Object.wait(long)

构造方法摘要

Timer()

创建一个新计时器。

Timer(boolean isDaemon)

创建一个新计时器,可以指定其相关的线程作为守护程序运行。

Timer(Stringname)

创建一个新计时器,其相关的线程具有指定的名称。

Timer(Stringname, boolean isDaemon)

创建一个新计时器,其相关的线程具有指定的名称,并且可以指定作为守护程序运

行。

方法摘要

void cancel()

终止此计时器,丢弃所有当前已安排的任务。

int purge()

从此计时器的任务队列中移除所有已取消的任务。

void schedule(TimerTasktask,Date time)

安排在指定的时间执行指定的任务。

void schedule(TimerTasktask,Date firstTime, long period)

安排指定的任务在指定的时间开始进行重复的固定延迟执行

void schedule(TimerTasktask, long delay)

安排在指定延迟后执行指定的任务。

void schedule(TimerTasktask, long delay, long period)

安排指定的任务从指定的延迟后开始进行重复的固定延迟执行

void scheduleAtFixedRate(TimerTasktask,Date firstTime, long period)

安排指定的任务在指定的时间开始进行重复的固定速率执行

void scheduleAtFixedRate(TimerTasktask, long delay, long period)

安排指定的任务在指定的延迟后开始进行重复的固定速率执行

从类java.lang.Object继承的方法

cloneequalsfinalize,getClass,hashCodenotify,notifyAll,toStringwait,wait,wait

构造方法详细信息

Timer

public Timer()

创建一个新计时器。相关的线程作为守护程序运行。

另请参见:

Thread,cancel()

Timer

public Timer(boolean isDaemon)

创建一个新计时器,可以指定其相关的线程作为守护程序运行。如果计时器将用于

安排重复的维护活动,则调用守护线程,在应用程序运行期间必须调用守护线程,

但是该操作不应延长程序的生命周期。

参数:

isDaemon -如果应该将相关的线程作为守护程序运行,则为true

另请参见:

Thread,cancel()

Timer

public Timer(Stringname)

创建一个新计时器,其相关的线程具有指定的名称。相关的线程作为守护程序运

行。

参数:

name -相关线程的名称。

抛出:

NullPointerException -如果namenull

从以下版本开始:

1.5

另请参见:

Thread.getName(),Thread.isDaemon()

Timer

public Timer(Stringname,

boolean isDaemon)

创建一个新计时器,其相关的线程具有指定的名称,并且可以指定作为守护程序运

行。

参数:

name -相关线程的名称。

isDaemon -如果应该将相关的线程作为守护程序运行,则为true

抛出:

NullPointerException -如果namenull

从以下版本开始:

1.5

另请参见:

Thread.getName(),Thread.isDaemon()

方法详细信息

schedule

public void schedule(TimerTasktask,

long delay)

安排在指定延迟后执行指定的任务。

参数:

task -所要安排的任务。

delay -执行任务前的延迟时间,单位是毫秒。

抛出:

IllegalArgumentException -如果delay是负数, 或者delay +

System.currentTimeMillis() 是负数。

IllegalStateException -如果已经安排或取消了任务,或者已经取消计时器。

schedule

public void schedule(TimerTasktask,

Date time)

安排在指定的时间执行指定的任务。如果此时间已过去,则安排立即执行该任务。

参数:

task -所要安排的任务。

time -执行任务的时间。

抛出:

IllegalArgumentException -如果time.getTime()是负数。

IllegalStateException -如果已经安排或取消了任务,已经取消了计时器,或者计时

器线程已终止。

schedule

public void schedule(TimerTasktask,

long delay,

long period)

安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。以近似固定的时间

间隔(由指定的周期分隔)进行后续执行。

在固定延迟执行中,根据前一次执行的实际执行时间来安排每次执行。如

果由于任何原因(如垃圾回收或其他后台活动)而延迟了某次执行,则后

续执行也将被延迟。从长期来看,执行的频率一般要稍慢于指定周期的倒

数(假定Object.wait(long)所依靠的系统时钟是准确的)。

固定延迟执行适用于那些需要“平稳”运行的重复活动。换句话说,它适

用于在短期运行中保持频率准确要比在长期运行中更为重要的活动。这包

括大多数动画任务,如以固定时间间隔闪烁的光标。这还包括为响应人类

活动所执行的固定活动,如在按住键时自动重复输入字符。

参数:

task -所要安排的任务。

delay -执行任务前的延迟时间,单位是毫秒。

period -执行各后续任务之间的时间间隔,单位是毫秒。

抛出:

IllegalArgumentException -如果delay是负数, 或者delay +

System.currentTimeMillis() 是负数。

IllegalStateException -如果已经安排或取消了任务,已经取消了计时器,或者计时

器线程已终止。

schedule

public void schedule(TimerTasktask,

Date firstTime,

long period)

安排指定的任务在指定的时间开始进行重复的固定延迟执行。以近似固定的时间间

隔(由指定的周期分隔)进行后续执行。

在固定延迟执行中,根据前一次执行的实际执行时间来安排每次执行。如

果由于任何原因(如垃圾回收或其他后台活动)而延迟了某次执行,则后

续执行也将被延迟。在长期运行中,执行的频率一般要稍慢于指定周期的

倒数(假定Object.wait(long)所依靠的系统时钟是准确的)。

固定延迟执行适用于那些需要“平稳”运行的重复执行活动。换句话说,

它适用于在短期运行中保持频率准确要比在长期运行中更为重要的活动。

这包括大多数动画任务,如以固定时间间隔闪烁的光标。这还包括为响应

人类活动所执行的固定活动,如在按住键时自动重复输入字符。

参数:

task -所要安排的任务。

firstTime -首次执行任务的时间。

period -执行各后续任务之间的时间间隔,单位是毫秒。

抛出:

IllegalArgumentException -如果time.getTime()是负数。

IllegalStateException -如果已经安排或取消了任务,已经取消了计时器,或者计时

器线程已终止。

scheduleAtFixedRate

public void scheduleAtFixedRate(TimerTasktask,

long delay,

long period)

安排指定的任务在指定的延迟后开始进行重复的固定速率执行。以近似固定的时间

间隔(由指定的周期分隔)进行后续执行。

在固定速率执行中,根据已安排的初始执行时间来安排每次执行。如果由

于任何原因(如垃圾回收或其他背景活动)而延迟了某次执行,则将快速

连续地出现两次或更多的执行,从而使后续执行能够“追赶上来”。从长

远来看,执行的频率将正好是指定周期的倒数(假定Object.wait(long)

所依靠的系统时钟是准确的)。

固定速率执行适用于那些对绝对时间敏感的重复执行活动,如每小时准

点打钟报时,或者在每天的特定时间运行已安排的维护活动。它还适用于

那些完成固定次数执行的总计时间很重要的重复活动,如倒计时的计时

器,每秒钟滴答一次,共10秒钟。最后,固定速率执行适用于安排多个

重复执行的计时器任务,这些任务相互之间必须保持同步。

参数:

task -所要安排的任务。

delay -执行任务前的延迟时间,单位是毫秒。

period -执行各后续任务之间的时间间隔,单位是毫秒。

抛出:

IllegalArgumentException -如果delay是负数, 或者delay +

System.currentTimeMillis() 是负数。

IllegalStateException -如果已经安排或取消了任务,已经取消了计时器,或者计时

器线程已终止。

scheduleAtFixedRate

public void scheduleAtFixedRate(TimerTasktask,

Date firstTime,

long period)

安排指定的任务在指定的时间开始进行重复的固定速率执行。以近似固定的时间间

隔(由指定的周期分隔)进行后续执行。

在固定速率执行中,相对于已安排的初始执行时间来安排每次执行。如果

由于任何原因(如垃圾回收或其他背景活动)而延迟了某次执行,则将快

速连续地出现两次或更多次执行,从而使后续执行能够赶上来。从长远来

看,执行的频率将正好是指定周期的倒数(假定Object.wait(long)

依靠的系统时钟是准确的)。

固定速率执行适用于那些对绝对时间敏感的重复执行活动,如每小时准

点打钟报时,或者在每天的特定时间运行已安排的维护活动。它还适用于

那些完成固定次数执行的总计时间很重要的重复活动,如倒计时的计时

器,每秒钟滴答一次,共10秒钟。最后,固定速率执行适用于安排多次

重复执行的计时器任务,这些任务相互之间必须保持同步。

参数:

task -所要安排的任务。

firstTime -首次执行任务的时间。

period -执行各后续任务之间的时间间隔,单位是毫秒。

抛出:

IllegalArgumentException -如果time.getTime()是负数。

IllegalStateException -如果已经安排或取消了任务,已经取消了计时器,或者计时

器线程已终止。

cancel

public void cancel()

终止此计时器,丢弃所有当前已安排的任务。这不会干扰当前正在执行的任务(如

果存在)。一旦终止了计时器,那么它的执行线程也会终止,并且无法根据它安排更

多的任务。

注意,在此计时器调用的计时器任务的run方法内调用此方法,就可以

绝对确保正在执行的任务是此计时器所执行的最后一个任务。

可以重复调用此方法;但是第二次和后续调用无效。

purge

public int purge()

从此计时器的任务队列中移除所有已取消的任务。调用此方法对计时器的行为没有

影响,但是将无法引用队列中已取消的任务。如果没有对这些任务的外部引用,则

它们就成为垃圾回收的合格对象。

多数程序无需调用此方法。它设计用于一些罕见的应用程序,这些程序可

取消大量的任务。调用此方法要以时间来换取空间:此方法的运行时可能

n + c log n呈正比,其中n是队列中的任务数,而是取消的任

务数。

注意,从此计时器上所安排的任务中调用此方法是允许的。

返回:

从队列中移除的任务数。

从以下版本开始:

1.5

下面是TimerTask类的介绍

java.util

TimerTask

java.lang.Object

java.util.TimerTask

所有已实现的接口:

Runnable

public abstract class TimerTask

extends Object

implements Runnable

Timer安排为一次执行或重复执行的任务。

从以下版本开始:

1.3

另请参见:

Timer

构造方法摘要

protected TimerTask()

创建一个新的计时器任务。

方法摘要

boolean cancel()

取消此计时器任务。

abstract void run()

此计时器任务要执行的操作。

long scheduledExecutionTime()

返回此任务最近实际执行的安排执行时间。

从类java.lang.Object继承的方法

cloneequalsfinalize,getClass,hashCodenotify,notifyAll,toStringwait,wait,wait

构造方法详细信息

TimerTask

protected TimerTask()

创建一个新的计时器任务。

方法详细信息

run

public abstract void run()

此计时器任务要执行的操作。

指定者:

接口Runnable中的run

另请参见:

Thread.run()

cancel

public boolean cancel()

取消此计时器任务。如果任务安排为一次执行且还未运行,或者尚未安排,则永远

不会运行。如果任务安排为重复执行,则永远不会再运行。(如果发生此调用时任务

正在运行,则任务将运行完,但永远不会再运行。)

注意,从重复的计时器任务的run方法中调用此方法绝对保证计时器任

务永远不会再运行。

此方法可以反复调用;第二次和以后的调用无效。

返回:

如果此任务安排为一次执行且尚未运行,或者此任务安排为重复执行,则返回true

如果此任务安排为一次执行且已经运行,或者此任务尚未安排,或者此任务已经取

消,则返回false。(一般来说,如果此方法阻止发生一个或多个安排执行,则返回

true。)

scheduledExecutionTime

public long scheduledExecutionTime()

返回此任务最近实际执行的安排执行时间。(如果在任务执行过程中调用此方法,

则返回值为此任务执行的安排执行时间。)

通常从一个任务的run方法中调用此方法,以确定当前任务执行是否能

充分及时地保证完成安排活动:

public void run() {

if (System.currentTimeMillis() - scheduledExecutionTime()

>=

MAX_TARDINESS)

return; // Too late; skip this execution.

// Perform the task

}

通常,此方法固定延迟执行的重复任务一起使用,因为其安排执行时间允许

随时间浮动,所以毫无意义。

返回:

最近发生此任务执行安排的时间,采用Date.getTime()返回的格式。如果任务已开

始其首次执行,则返回值不确定。

另请参见:

Date.getTime()

展开阅读全文

没有更多推荐了,返回首页