精华内容
下载资源
问答
  • 下面是一个在Android中使用定时器Timer和TimerTask的启动,停止,暂停,继续等操作的demo。 需要注意的问题主要有两点: 1、Timer和TimerTask在调用cancel()取消后不能再执行 schedule语句 2、只能在UI主线程中更新...
  • Java中的Timer和TimerTask简介(附完整代码实例)。 在Java中,Timer和TimerTask是两个经常用来实现定时器的类。这两个类使用起来非常方便,可以完成我们对定时器的绝大多数需求。 Timer是一种定时器工具,用来在一...
  • NULL 博文链接:https://fly2000.iteye.com/blog/292847
  • 详解JAVA Timer和TimerTask

    2020-08-18 17:07:03
    主要介绍了JAVA Timer和TimerTask的相关资料,文中讲解非常细致,代码帮助大家更好的理解学习,感兴趣的朋友可以了解下
  • 下面小编就为大家带来一篇浅谈Timer和TimerTask与线程的关系。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Timer和TimerTask

    2020-06-15 22:08:20
    Timer TimerTsak 定时任务TimerTask简介 定时器Timer简介 Timer关键函数 定时器的一般使用方法 实践:倒计时小程序 定时任务TimerTask TimerTask 一个抽象类(实现的时候必须重写run方法),它的子类代表一个...

    Timer 和 TimerTsak

    1. 定时任务TimerTask简介
    2. 定时器Timer简介
    3. Timer关键函数
    4. 定时器的一般使用方法
    5. 实践:倒计时小程序
    定时任务TimerTask
    • TimerTask 一个抽象类(实现的时候必须重写run方法),它的子类代表一个可以被Timer计划的任务,类似于Runnable。

    • 注意:Timertask作为一个在子线程中运行的任务不能够直接操作UI控件,可以在run方法中给主线程发消息。

    • m_timer = new Timer();
      m_timer.schedule(new TimerTask(){
      	@Override
          public void run(){
              Message message = new Message();
              message.what = MainActivity.message_code_updateplaytime;
              uihandler.sendMessage(message);
          }
      },50,1000);
      
    定时器Timer
    • Timer类负责创建、管理和 执行线程。
    • Timer是一种定时器工具,用来在一个后台线程计划执行指定任务。它可以计划执行一个任务一次或反复多次。
    Timer关键函数
    • Timer.cancel():停止一个Timer并终止后台线程,取消所有计划任务。

    • Timer。purge():移除列表中所有计时器

    • Timer类的主要方法是schedule,共有四个参数不相同的重载方法,可以在方法中指定线程运行的任务、任务执行的开始时间、任务执行的间隔时间

      schedule(TimerTask,long):void
      schedule(TimerTask,Date):void
      schedule(TimerTask,long,long):void
      schedule(TimerTask,Date,long):void
      
    Timer关键函数 - schedule
    • void schedule(TimeTask task,long delay)
      • 延迟delay个毫秒后,执行task,只执行一次。
    • void schedule(TimerTask task,long delay,long period)
      • 延迟delay个毫秒后,执行task,之后每隔peroid毫秒执行一次任务
    定时器一般使用方法
    • 要使用Timer线程:
      • 首先要定义一个TimerTask的子类
      • 然后在主程序中定义一个Timer对象和TimerTask对象
      • 把TimerTask对象作为Timer对象的schedule()方法的参数进行任务的调度
    public class TimerExample{
        public static void main(String[] agrs){
            Timer timer1 = new Timer();
            Timer timer2 = new Timer();
            MyThread thread1 = new MyThread("线程一");
            MyThread thread2 = new MyThread("线程二");
    		timer1.schedule(thread1,0);
            timer2.schedule(thread2,0);
        }
    }
    class Mythread extends TimerTask{
        Random rm;
        String name;
        
        public MyThread(String tName){
            this.name = tName;
            rm = new Random();
        }
        public void run(){
            for(int i =1 ; i <= 10; i++){
                System.out.println(i+ " " + name);
                try{//随机休眠一段时间,以打乱线程的执行顺序
                    Thread.sleep(rm.newxInt(1000));
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println(name+"完成!");
        }
    }
    
    用Timer实现倒计时小程序
    import java.util.Random;
    import java,util.Timer;
    import java.util.TimerTask;
    
    import android.app.Activity;
    import android.os.Bundle;
    
    public class DemoTimerA ectends Activity{
        @Override
        protected void onCreate(Bundle saveInstanceState){
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            System.out.println("This is main thread...");
            
            //1.定义一个计时器
            final Timer timer = new Timer();
            //2.定义一个计时器任务,重写run()方法
            TimerTask timertask = new TimerTask(){
                @Override
                public void run(){
                    try{
                        System.out.println("sub thread is begin...");
                        Random rm = new Random();
                        Thread.sleep(rm.nextInt(1000));
                        System.out.println("sub thread is finished!");
                        
                        if(timer != null){
                            timer.cancel();
                            timer.purge();
                        }
                    }catch(InterrupteredException e){
                        e.printStackTrace();
                    }
                }
            };
            System.out.println("This is main thread!");
            //3.利用Timer制定task的执行计划
            //3.1这里用schedule方法,第一个参数是TimerTask对象,第二个参数拜师开始执行前延时时间(单位是millisecond)
            timer.scheedule(timertaska,1000);
            //3.2这里用schedule方法,第一个参数是TImerTask对象,第二个参数表示开始执行前的延时时间(单位是millisecond)
            m_timer.schedule(m_timertask,0,2000);//每隔2s执行一次
        }
    }
    
    展开全文
  • 主要为大家详细介绍了java定时任务Timer和TimerTask使用方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java定时器-Timer和TimerTask详解

    万次阅读 2018-07-17 17:44:16
    1、例子入手 package pers.growing.test;...import java.util.Timer; import java.util.TimerTask; public class Main { /** * 延迟100ms后,间隔1s打印出:hello world * * @param args * @throws Inte...

    1、例子入手

    package pers.growing.test;
    
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class Main {
    
        /**
         * 延迟100ms后,间隔1s打印出:hello world
         *
         * @param args
         * @throws InterruptedException
         */
        public static void main(String[] args) throws InterruptedException {
            Timer t = new Timer();
            t.scheduleAtFixedRate(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("hello world");
                }
            }, 100, 1000);
    
        }
    
    }

    结果:

    hello world
    hello world
    hello world
    hello world
    hello world
    hello world
    hello world

    2、类讲解

    TimerTask.java:主要为任务的具体内容。

    Timer.java中含有3个类:Timer、TimerThread、TaskQueue。

    三者关系为:TaskQueue中存放一些列将要执行的TimerTask,以数组的形式存放,下标约小(注:下标为0不处理,即使用的最小下标为1),则表明优先级越高。

    TimerThread为Thread的扩展类,会一直从TaskQueue中获取下标为1的TimerTask进行执行。并根据该TimerTask是否需要重复执行来决定是否放回到TaskQueue中。

    Timer用于配置用户期望的任务执行时间、执行次数、执行内容。它内部会配置TimerThread、TaskQueue。

    3、源码解读

    Timer类下的方法如下:

    Timer中涉及到4个成员变量,queue、thread已经在上面介绍过了,对于nextSerialNumber,只是用于命名默认的thread名称使用。threadReaper为了在GC时进行相关处理,后面再介绍。

    Timer的构造函数实现大同小异,以Timer(String,boolean)为例:

      public Timer(String name, boolean isDaemon) {
            thread.setName(name); //设置成员变量的线程名称
            thread.setDaemon(isDaemon); //该线程是否为守护线程
            thread.start();//起线程
        }

    schedule()以schedule(TimerTask,long,long)为例:

     public void schedule(TimerTask task, long delay, long period) {
            if (delay < 0)
                throw new IllegalArgumentException("Negative delay.");
            if (period <= 0)
                throw new IllegalArgumentException("Non-positive period.");
            sched(task, System.currentTimeMillis()+delay, -period); //最后调用了sched方法
        }

    这一块有困惑的可能是为什么period取了负数?而且所有的schedule(...)方法,最后传给sched中的period都是负的。之后再介绍。

    scheduleAtFixedRate()以scheduleAtFixedRate(TimerTask,long,long)为例:

        public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
            if (delay < 0)
                throw new IllegalArgumentException("Negative delay.");
            if (period <= 0)
                throw new IllegalArgumentException("Non-positive period.");
            sched(task, System.currentTimeMillis()+delay, period); //也是调用sched方法
        }

    此时会发现schedule与scheduleAtFixedRate似乎区别不大,唯一有区别的是schedule最后传值给sched的period是负数,而scheduleAtFixedRate传的是正数。

    在schedule方法的注释上,有这段内容:

         * <p>In fixed-delay execution, each execution is scheduled relative to
         * the actual execution time of the previous execution.  If an execution
         * is delayed for any reason (such as garbage collection or other
         * background activity), subsequent executions will be delayed as well.
         * In the long run, the frequency of execution will generally be slightly
         * lower than the reciprocal of the specified period (assuming the system
         * clock underlying <tt>Object.wait(long)</tt> is accurate).

    翻译:如果出现某一次任务的延迟,那么之后的任务都会以period为周期进行延迟。

    而scheduleAtFixedRate方法也有对应注释:

         * <p>In fixed-rate execution, each execution is scheduled relative to the
         * scheduled execution time of the initial execution.  If an execution is
         * delayed for any reason (such as garbage collection or other background
         * activity), two or more executions will occur in rapid succession to
         * "catch up."  In the long run, the frequency of execution will be
         * exactly the reciprocal of the specified period (assuming the system
         * clock underlying <tt>Object.wait(long)</tt> is accurate).

    翻译:每次的执行都是以初始时计算好的时间为准,如果出现某次任务的延迟,则之后的任务会快速执行,即按计划时间执行。

    那么看下Sched()方法实现:

     private void sched(TimerTask task, long time, long period) {//接收具体任务,第一次执行时间,周期
            if (time < 0)
                throw new IllegalArgumentException("Illegal execution time.");
    
            // Constrain value of period sufficiently to prevent numeric
            // overflow while still being effectively infinitely large.
            if (Math.abs(period) > (Long.MAX_VALUE >> 1))
                period >>= 1;
    
            synchronized(queue) {
                if (!thread.newTasksMayBeScheduled)
                    throw new IllegalStateException("Timer already cancelled.");
    
                synchronized(task.lock) {
                    if (task.state != TimerTask.VIRGIN)
                        throw new IllegalStateException(
                            "Task already scheduled or cancelled");
                    task.nextExecutionTime = time; //给TimerTask赋值
                    task.period = period;
                    task.state = TimerTask.SCHEDULED;
                }
    
                queue.add(task);//将TimerTask放到队列中,并进行队列排序
                if (queue.getMin() == task)//如果队列里恰好下标为1的任务为当前的task,则直接唤醒
                    queue.notify();
            }
        }

    queue中的add和getMin操作如下:

        void add(TimerTask task) {
            // Grow backing store if necessary
            if (size + 1 == queue.length)
                queue = Arrays.copyOf(queue, 2*queue.length);
    
            queue[++size] = task;
            fixUp(size);//让task进行排序,排序并不是十分严谨,将nextExecutionTime较小的往前排
        }
    
        private void fixUp(int k) {
            while (k > 1) {
                int j = k >> 1;
                if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
                    break;
                TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
                k = j;
            }
        }
    
       
        TimerTask getMin() { //注意最小的值是从下标为1的获取,queue[0]其实没用到
            return queue[1];
        }

    数据已经放到queue中了,那么看下是什么时候执行的。在之前Timer的构造函数这块,有一句是:thread.start();说明TimerThread在Timer初始化之后就一直启用着,那看下它的处理。

     public void run() {
            try {
                mainLoop(); //主要实现内容
            } finally {
                // Someone killed this Thread, behave as if Timer cancelled
                synchronized(queue) {
                    newTasksMayBeScheduled = false;
                    queue.clear();  // Eliminate obsolete references
                }
            }
        }
    
        /**
         * The main timer loop.  (See class comment.)
         */
        private void mainLoop() {
            while (true) {
                try {
                    TimerTask task;
                    boolean taskFired;
                    synchronized(queue) {
                        // Wait for queue to become non-empty
                       //如果队列为空并且是有标志位,则等待。没有标志位的情况为不在需要执行timer了,比如cancel或被gc的时候
                        while (queue.isEmpty() && newTasksMayBeScheduled) 
                            queue.wait();
                        if (queue.isEmpty())
                            break; // Queue is empty and will forever remain; die
    
                        // Queue nonempty; look at first evt and do the right thing
                        long currentTime, executionTime;//分别是当前时间、理论执行时间
                        task = queue.getMin();//获取就近的task
                        synchronized(task.lock) {
                           //如果该task已经被置为cancelled,则将它从队列里面移出
                            if (task.state == TimerTask.CANCELLED) {
                                queue.removeMin();
                                continue;  // No action required, poll queue again
                            }
                            currentTime = System.currentTimeMillis();
                            executionTime = task.nextExecutionTime;
                            if (taskFired = (executionTime<=currentTime)) {
                                if (task.period == 0) { // period表示该task是一次性的,用完就移出
                                    queue.removeMin();//移出task,这块会有queue的重新排序
                                    task.state = TimerTask.EXECUTED;//更新状态为执行中
                                } else {
                            //可重复执行的task操作,将重新计算下次执行时间,并重新排序    
                    //重点,此处解释为什么period分正负:区别schedule方法和scheduleAtFixedRate
                            //如果是负数,则以当前时间为准,往后计算下次执行时间
                            //如果是正数,则以理论时间为准,往后计算下次执行时间
                                    queue.rescheduleMin(
                                      task.period<0 ? currentTime   - task.period
                                                    : executionTime + task.period);
                                }
                            }
                        }
                        if (!taskFired) // 如果还没到任务执行时间就处于等待
                            queue.wait(executionTime - currentTime);
                    }
                    if (taskFired)  // 到执行时间了
                    //执行task中的run方法,而不是start方法,所以并不是另起一个线程进行操作
                        task.run();
                } catch(InterruptedException e) {//如果是不能捕获的异常,就会有风险了
                }
            }
        }

    关于queue中的removeMin()和rescheduleMin()方法如下:

        void removeMin() {//前两行赋值可能会将queue乱序,所以才会有fixDown重新排序
            queue[1] = queue[size];
            queue[size--] = null;  // Drop extra reference to prevent memory leak
            fixDown(1);
        }
    
        //因为取的时候也是取下标为1的task进行操作,所以此次也是将下标为1的task重新赋时间,并排序
        void rescheduleMin(long newTime) {
            queue[1].nextExecutionTime = newTime;
            fixDown(1);
        }
    
        //和fixUp方法类似,该排序单独看也并非严谨,但由于每次操作都会经历,所以应该是准的吧!
        private void fixDown(int k) {
            int j;
            while ((j = k << 1) <= size && j > 0) {
                if (j < size &&
                    queue[j].nextExecutionTime > queue[j+1].nextExecutionTime)
                    j++; // j indexes smallest kid
                if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
                    break;
                TimerTask tmp = queue[j];  queue[j] = queue[k]; queue[k] = tmp;
                k = j;
            }
        }

    当timerTask调用了timerTask.cancel()操作时,也可以人为的将它从Timer队列中清除掉,方法如下:

     public int purge() {
             int result = 0;
    
             synchronized(queue) {
                 for (int i = queue.size(); i > 0; i--) {
                     if (queue.get(i).state == TimerTask.CANCELLED) {
                         queue.quickRemove(i); //由于i取值时必然大于0,所以肯定能够找到正常的数据
                         result++;
                     }
                 }
    
                 if (result != 0)
                     queue.heapify();//重新排序
             }
    
             return result;
         }

    queue中的quickRemove和heapify方法:

        void quickRemove(int i) { //只要简单赋值就行了,最后排序交给heapify()
            assert i <= size;
    
            queue[i] = queue[size];
            queue[size--] = null;  // Drop extra ref to prevent memory leak
        }
    
        void heapify() {
            for (int i = size/2; i >= 1; i--)
                fixDown(i); //在前面的篇幅中介绍过了
        }

    当然如果Timer也可以人为的取消,不在继续定时任务。其方法如下:

       public void cancel() {
            synchronized(queue) {
                thread.newTasksMayBeScheduled = false;
                queue.clear(); //会将队列中的所有的task赋值为null
                queue.notify();  // 通知thread中的mainLoop进行break操作
            }
        }

    综上,其实大部分流程就屡清楚了。顺带介绍下Timer中的threadReaper。代码如下:

       /**
         * This object causes the timer's task execution thread to exit
         * gracefully when there are no live references to the Timer object and no
         * tasks in the timer queue.  It is used in preference to a finalizer on
         * Timer as such a finalizer would be susceptible to a subclass's
         * finalizer forgetting to call it.
         */
        private final Object threadReaper = new Object() {
            protected void finalize() throws Throwable {
                synchronized(queue) {
                    thread.newTasksMayBeScheduled = false;
                    queue.notify(); // In case queue is empty.
                }
            }
        };

    重写了finalize方法,该方法为GC时候调用,主要使Timer中的thread能够优雅退出。

    4、总结

    优势:可以实现比较轻量级的定时任务,而且很方便

    劣势:

    ①由于Timer只是创建了一个thread去执行queue中的task,那么就可能会出现上一个任务执行延迟了,会影响到下一个定时任务。

    ②在TimerThread#mainloop中,也可看到,如果抛出了InterruptedException之外无法捕获到的异常时,mainloop就会中断,Timer也就无法使用了。

     

              

    展开全文
  • 本篇文章主要介绍了解析Java中的Timer和TimerTask在Android中的用法,主要介绍了Timer和TimerTask的用法,有需要的可以了解一下。
  • 下面小编就为大家带来一篇java之Timer和TimerTask简单demo(分享)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Timer是一种线程设施,用于安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行,可以看成一个定时器,可以调度TimerTaskTimerTask是一个抽象类,实现了Runnable接口,所以具备了多线程的能力...

    Timer是一种线程设施,用于安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行,可以看成一个定时器,可以调度TimerTask。TimerTask是一个抽象类,实现了Runnable接口,所以具备了多线程的能力。

    测试代码:

    import java.util.TimerTask;

      

    public class OneTask extends TimerTask{

      

        private int id;

        public OneTask(int id){

            this.id = id;

        }

          

        @Override

        public void run() {

            System.out.println("线程"+ id +":  正在 执行。。"); 

            //System.gc();

        }   

    }

    然后主程序代码为:

    import java.util.Date;

    import java.util.Timer;

    public class Test1 {  

        public static void main(String[] args) {

            Timer timer = new Timer(); 

            timer.schedule(new OneTask(1), 5000);// 5秒后启动任务 

            OneTask secondTask= new OneTask(2);

            timer.schedule(secondTask, 1000, 3000);// 1秒后启动任务,以后每隔3秒执行一次线程     

            Date date = new Date();

            timer.schedule(new OneTask(3),new Date(date.getTime()+1000));//以date为参数,指定某个时间点执行线程       

    //      timer.cancel();

    //      secondTask.cancel();

            System.out.println("end in main thread...");

        }

    }


     

    Timer里面有4个schedule重载函数。而且还有两个scheduleAtFixedRate:

    void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
    安排指定的任务在指定的时间开始进行重复的固定速率执行。
    void scheduleAtFixedRate(TimerTask task, long delay, long period)
    安排指定的任务在指定的延迟后开始进行重复的固定速率执行。

    使用scheduleAtFixedRate的话, Timer会尽量的让任务在一个固定的频率下运行。例如:在上面的例子中,让secondTask在1秒钟后,每3秒钟执行一次,但是因为java不是实时的,所以,我们在上个程序中表达的原义并不能够严格执行,例如有时可能资源调度紧张4秒以后才执行下一次,有时候又3.5秒执行。如果我们调用的是scheduleAtFixedRate,那么Timer会尽量让你的secondTask执行的频率保持在3秒一次。运行上面的程序,假设使用的是scheduleAtFixedRate,那么下面的场景就是可能的:1秒钟后,secondTask执行一次,因为系统繁忙,之后的3.5秒后secondTask才得以执行第二次,然后Timer记下了这个延迟,并尝试在下一个任务的时候弥补这个延迟,那么2.5秒后,secondTask 将执行的三次。“以固定的频率而不是固定的延迟时间去执行一个任务”就是这个意思。

    Timer终止的问题:

    默认情况下,只要一个程序的timer线程在运行,那么这个程序就会保持运行。可以通过以下3种方法终止一个timer线程:
    (1)调用timer的cancle方法。你可以从程序的任何地方调用此方法,甚至在一个timer task的run方法里;
    (2)让timer线程成为一个daemon线程(可以在创建timer时使用new Timer(true)达到这个目地),这样当程序只有daemon线程的时候,它就会自动终止运行;
    (3)调用System.exit方法,使整个程序(所有线程)终止。

    TimerTask也有cancel方法。

    上面所说的“只要一个程序的timer线程在运行,那么这个程序就会保持运行”。那么反过来,如果Timer里的所有TimerTask都执行完了,整个程序会退出吗,经测试答案是否定的,例如上面的测试代码,如果只加第一个TimerTask在Timer中执行:

    timer.schedule(new OneTask(1), 5000);// 5秒后启动任务
    那么5秒以后,其实整个程序还是没有退出,Timer会等待垃圾回收的时候被回收掉然后程序会得以退出,但是多长时间呢?

    在TimerTask的run函数执行完以后加上System.gc();就可以了。

    展开全文
  • 主要介绍了Java 中Timer和TimerTask 定时器定时任务使用的例子,非常具有实用价值,需要的朋友可以参考下
  • Android 中 Timer TimerTask的使用

    千次阅读 2019-01-24 18:16:32
    Android 中 Timer TimerTask的使用 https://www.jianshu.com/p/89ca760af5f1

    Android 中 Timer 和 TimerTask的使用
    https://www.jianshu.com/p/89ca760af5f1

    展开全文
  • Java中的Timer和TimerTask的用法

    千次阅读 2018-03-09 10:06:18
    Timer是一个普通的类,其中有几个重要的方法; 而TimerTask则是一个抽象类,其 中有一个抽象方法run(),类型线程中的run()方法。 我们使用Timer创建一个他的对象,然后使用这对象的schedule方法来完成这种间隔的...
  • Timer和TimerTask的简单介绍

    千次阅读 2018-07-09 11:09:51
    1.Timer和TimerTask Timer是jdk中提供的一个定时器工具,使用的时候会在主线程之外起一个单独的线程执行指定的计划任务,可以指定执行一次或者反复执行多次。 TimerTask是一个实现了Runnable接口的抽象类,代表一...
  • Java Timer TimerTask

    2016-11-21 11:54:41
    Timer是一个普通的类,其中有几个重要的方法;而TimerTask则是一个抽象类,其中有一个抽象方法run(),类型线程中的run()方法。我们使用Timer创建一个他的对象,然后使用这对象的schedule方法来完成这种间隔的操作。...
  • 1:java.util.Timer定时器的常用方法如下: 2:参数含义: 3.暂停任务: 4.例子: 1:java.util.Timer定时器的常用方法如下: schedule(TimerTask task, long delay) // 延迟delay毫秒后,执行一次task。 ...
  • NULL 博文链接:https://zhouhaitao.iteye.com/blog/1199750
  • 值得注意的是TimerTimerTask,cancel之后就需要重新声明一个对象,否则会报错的哦~ package zhexian.app.myapplication; import android.util.Log; import java.util.Timer; imp...
  • Android Timer和TimerTask

    千次阅读 2018-10-26 15:46:20
    1.概览 Timer是一种定时器工具...TimerTask一个抽象类,它的子类代表一个可以被Timer计划的任务。 最简单常用的用法实例: private Timer mTimer = new Timer(); private TimerTask mTimerTask; private int...
  • 原文:java定时任务类Timer和TimerTask用法详解 代码下载地址:...java定时任务类Timer和TimerTask用法详解 package com.zuidaima.util; import java.io.IOException; import java.util....
  • TimerTimerTask(计时器)
  • <%@page import="java.util.Iterator"%> <%@page import="java.util.Set"%...%@page import="java.util.TimerTask"%> <%@page import="java.util.Date"%> <%@page import="java.util.Timer"%>.
  • 1、timer和timertask是否运行在主线程中?答案是否定的。 下面是在UI线程打印的UI线程ID System.out.println("-=-=-=>>ui...xianchengid00000 = " + Thread.currentThread().getId()); 下面是在timertask的...
  • Java中的Timer和TimerTask在Android中的用法

    万次阅读 多人点赞 2012-11-10 11:07:31
    比如UI上的控件需要随着时间改变,我们可以使用Java为我们提供的计时器的工具类,即Timer和TimerTask。  Timer是一个普通的类,其中有几个重要的方法;而TimerTask则是一个抽象类,其中有一个抽象方法run(),...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,296
精华内容 14,518
关键字:

timer和timertask