精华内容
下载资源
问答
  • 定时器Android

    2016-03-24 16:09:15
    错误的定时器写法一:@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.

    定时器postDelayed的实现
    这是一种可以创建多线程消息的函数
    使用方法:
    1,首先创建一个Handler对象
    Handler handler=new Handler();
    2,然后创建一个Runnable对象
    Runnable runnable=new Runnable(){
    @Override
    public void run() {
    // TODO Auto-generated method stub
    //要做的事情,这里再次调用此Runnable对象,以实现每两秒实现一次的定时器操作
    handler.postDelayed(this, 2000);
    }
    };
    3,使用PostDelayed方法,两秒后调用此Runnable对象
    handler.postDelayed(runnable, 2000);
    实际上也就实现了一个2s的一个定时器
    4,如果想要关闭此定时器,可以这样操作
    handler.removeCallbacks(runnable);

    当然,你也可以做一个闹钟提醒延时的函数试试,比如,先用MediaPlayer播放闹钟声音,
    如果不想起,被停止播放之后,下次就5分钟后再播放,再被停止的话,下次就4分钟后播放,
    ………………
    只要更改延时的时间就可以实现了,用一个static对象的话会比较容易操作。

    错误的定时器写法一:

    @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            requestWindowFeature(Window.FEATURE_NO_TITLE);
            setContentView(R.layout.fragment_main);
            final TextView tv = (TextView) findViewById(R.id.tv);
            tvShow = (TextView) findViewById(R.id.tv_show);
            new Handler().postDelayed(new Runnable() {
    
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    int i = 0;
                    tv.setText(""+i+"");
                    System.out.println("i--->" + i);
                }
            }, 1000);
    
        }

    直接使用new Handler().postDelayed();这种方式无法实现定时器操作。原因我也没分析出来。
    错误的定时器写法二:

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            requestWindowFeature(Window.FEATURE_NO_TITLE);
            setContentView(R.layout.fragment_main);
            tvShow = (TextView) findViewById(R.id.tv_show);
            new Thread(new ThreadShow()).start();  
        }
     // 线程类  
        class ThreadShow implements Runnable {
    
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while (true) {
                    try {
                        Thread.sleep(1000);
                        tvShow.setText(Integer.toString(i++)); 
                        System.out.println("send...");
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        System.out.println("thread error...");
                    }
                }
            }
        }
    

    线程类中无法操作控件元素TextView。所以需要接住Message类来传递给Handler类。
    以下三种是正确的定时器写法。
    方法一:Handler+Thread

    package com.xunfang.handerDemo;  
    
    import android.app.Activity;  
    import android.os.Bundle;  
    import android.os.Handler;  
    import android.os.Message;  
    import android.widget.TextView;  
    
    /** 
     * handler定时器 
     *  
     * @author Smalt 
     *  
     */  
    public class HanderDemoActivity extends Activity {  
        TextView tvShow;  
        private int i = 0;  
    
        @Override  
        public void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.main);  
            tvShow = (TextView) findViewById(R.id.tv_show);  
            new Thread(new ThreadShow()).start();  
        }  
    
        // handler类接收数据  
        Handler handler = new Handler() {  
            public void handleMessage(Message msg) {  
                if (msg.what == 1) {  
                    tvShow.setText(Integer.toString(i++));  
                    System.out.println("receive....");  
                }  
            };  
        };  
    
        // 线程类  
        class ThreadShow implements Runnable {  
    
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                while (true) {  
                    try {  
                        Thread.sleep(1000);  
                        Message msg = new Message();  
                        msg.what = 1;  
                        handler.sendMessage(msg);  
                        System.out.println("send...");  
                    } catch (Exception e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                        System.out.println("thread error...");  
                    }  
                }  
            }  
        }  
    }  

    方法二:Handler类自带的postDelyed

    package com.xunfang.handerDemo;  
    
    import android.app.Activity;  
    import android.os.Bundle;  
    import android.os.Handler;  
    import android.widget.TextView;  
    
    /** 
     * handler定时器使用postDelyed实现 
     *  
     * @author Smalt 
     *  
     */  
    public class HanderDemoActivity extends Activity {  
        TextView tvShow;  
        private int i = 0;  
        private int TIME = 1000;  
    
        @Override  
        public void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.main);  
            tvShow = (TextView) findViewById(R.id.tv_show);  
            handler.postDelayed(runnable, TIME); //每隔1s执行  
        }  
    
        Handler handler = new Handler();  
        Runnable runnable = new Runnable() {  
    
            @Override  
            public void run() {  
                // handler自带方法实现定时器  
                try {  
                    handler.postDelayed(this, TIME);  
                    tvShow.setText(Integer.toString(i++));  
                    System.out.println("do...");  
                } catch (Exception e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                    System.out.println("exception...");  
                }  
            }  
        };  
    
    }  

    方法三:Handler+Timer+TimerTask

    package com.xunfang.handerDemo;  
    
    import java.util.Timer;  
    import java.util.TimerTask;  
    
    import android.app.Activity;  
    import android.os.Bundle;  
    import android.os.Handler;  
    import android.os.Message;  
    import android.widget.TextView;  
    
    /** 
     * 定时器实现:Handler+Timer+TimerTask 
     *  
     * @author Smalt 
     *  
     */  
    public class HanderDemoActivity extends Activity {  
        TextView tvShow;  
        private int i = 0;  
        private int TIME = 1000;  
    
        @Override  
        public void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.main);  
            tvShow = (TextView) findViewById(R.id.tv_show);  
            timer.schedule(task, 1000, 1000); // 1s后执行task,经过1s再次执行  
        }  
    
        Handler handler = new Handler() {  
            public void handleMessage(Message msg) {  
                if (msg.what == 1) {  
                    tvShow.setText(Integer.toString(i++));  
                }  
                super.handleMessage(msg);  
            };  
        };  
        Timer timer = new Timer();  
        TimerTask task = new TimerTask() {  
    
            @Override  
            public void run() {  
                // 需要做的事:发送消息  
                Message message = new Message();  
                message.what = 1;  
                handler.sendMessage(message);  
            }  
        };  
    }  
    展开全文
  • 实际上实现也很简单我们可以通过android原生自带的定时器完成,说下思路: 1.首先实现android定时器开启触发 2.在定时器结束的方法中再次触发开启定时器即可 package com.wyze.mercury.common.utils; import ...

    老套路看图:

    每隔20秒重新触发

    实际上实现也很简单我们可以通过android原生自带的定时器完成,说下思路:

    1.首先实现android定时器开启触发

    2.在定时器结束的方法中再次触发开启定时器即可

    package com.wyze.mercury.common.utils;
    
    import android.os.CountDownTimer;
    
    import com.wyze.mercury.common.TimerListener;
    import com.wyze.platformkit.utils.log.WpkLogUtil;
    
    /**
     * @author : xiayiye5
     * @date : 2021/1/8 18:10
     * 类描述 : Android定时器每隔一段时间刷新灯的状态
     */
    public class CountDownTimerUtils {
    
        private CountDownTimer countDownTimer;
    
        private CountDownTimerUtils() {
        }
    
        public static CountDownTimerUtils getInstance() {
            return Single.COUNT_DOWN_TIMER_UTILS;
        }
    
        public CountDownTimerUtils setTime(final TimerListener timerListener) {
            if (null == countDownTimer) {
                countDownTimer = new CountDownTimer(20 * 1000L, 1000) {
                    @Override
                    public void onTick(long l) {
                        WpkLogUtil.e("定时器", l / 1000 + "");
                    }
    
                    @Override
                    public void onFinish() {
                        WpkLogUtil.e("定时器", Thread.currentThread().getName());
                        //执行获取灯的状态
                        timerListener.timeFinish();
                        //继续定时
                        countDownTimer.start();
                    }
                };
            }
            return this;
        }
    
        private static final class Single {
            private static final CountDownTimerUtils COUNT_DOWN_TIMER_UTILS = new CountDownTimerUtils();
        }
    
        /**
         * 开始定时
         */
        public void startTime() {
            if (null != countDownTimer) {
                countDownTimer.start();
            }
        }
    
        /**
         * 取消定时
         */
        public void cancelTime() {
            if (null != countDownTimer) {
                countDownTimer.cancel();
                //切记置空
                countDownTimer = null;
            }
        }
    }
    

    注意:一定要做好生命周期的管理如下,个人建议开启定时器方法放到onStart生命周期中调用

      @Override
        protected void onStart() {
            super.onStart();
            CountDownTimerUtils.getInstance().setTime(new TimerListener() {
                @Override
                public void timeFinish() {
                    //每隔一段时间刷新灯的状态
                    getIotProp();
                }
            }).startTime();
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            //销毁的时候一定要取消定时器避免内存泄漏
            CountDownTimerUtils.getInstance().cancelTime();
        }
    
        @Override
        protected void onPause() {
            super.onPause();
            CountDownTimerUtils.getInstance().cancelTime();
        }

    在看下回调接口

    package com.wyze.mercury.listener;
    
    /**
     * @author : xiayiye5
     * @date : 2021/1/8 15:17
     * 类描述 :
     */
    public interface TimerListener {
        /**
         * 定时完成
         */
        void timeFinish();
    }
    

     

    展开全文
  • android 定时器

    2021-05-11 17:52:23
    android 定时器
  • android定时器

    2015-01-08 19:41:12
    android定时器
  • Android定时器

    2012-10-10 16:28:30
    android实现定时器 部分游戏源代码
  • Android程序源码--定时器

    热门讨论 2012-01-02 12:55:54
    Android程序源码--定时器,定时器Android程序源码
  • 翻转时钟定时器 Android 翻转时钟定时器 实现
  • Android 定时器

    2011-07-18 15:59:55
    Android 定时器

    在Android上常用的定时器有两种,一种是Java.util.Timer,一种就是系统的AlarmService了。 


    实验1:使用Java.util.Timer。 
    在onStart()创创建Timer,每5秒更新一次计数器,并启动。 

    	/** 定时发送 */
    	public void SendInTime(String msg, Handler mhandler) {
    		handler = mhandler;
    		timer = new Timer();
    
    		// 在1秒后执行此任务,每次间隔2秒,如果传递一个Data参数,就可以在某个固定的时间执行这个任务.
    		timer.schedule(new MyTask(msg), Constant.DELAY, Constant.PEROID);
    	}

     

    class MyTask extends java.util.TimerTask {
    		String msg;
    
    		public MyTask(String msg) {
    			this.msg = msg;
    		}
    
    		@Override
    		public void run() {
    			System.out.println("________");// 定时任务主要实现
    			try {
    				send(msg.getBytes("utf-8"), handler);
    			} catch (UnsupportedEncodingException e) {
    				e.printStackTrace();
    			}
    		}
    	}


     


    当连接USB线进行调试时,会发现一切工作正常,每5秒更新一次界面,即使是按下电源键,仍然会5秒触发一次。 
    当拔掉USB线,按下电源键关闭屏幕后,过一段时间再打开,发现定时器明显没有继续计数,停留在了关闭电源键时的数字。 

    实验2:使用AlarmService: 
    2.1通过AlarmService每个5秒发送一个广播,setRepeating时的类型为AlarmManager.ELAPSED_REALTIME。 

    AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);    
    
    am.setRepeating(AlarmManager.ELAPSED_REALTIME, firstTime, 5*1000, sender); 


    拔掉USB线,按下电源键,过一段时间再次打开屏幕,发现定时器没有继续计数。 
    2.2setRepeating是的类型设置为AlarmManager.ELAPSED_REALTIME_WAKEUP 

    AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);     
    
    am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, firstTime, 5*1000, sender); 


     

    展开全文
  • 一、TimerTimer是Android直接启动定时器的类,TimerTask是一个子线程,方便处理一些比较复杂耗时的功能逻辑,经常与handler结合使用。跟handler自身实现的定时器相比,Timer可以做一些复杂的处理,例如,需要对有大量...

    一、Timer

    Timer是Android直接启动定时器的类,TimerTask是一个子线程,方便处理一些比较复杂耗时的功能逻辑,经常与handler结合使用。

    跟handler自身实现的定时器相比,Timer可以做一些复杂的处理,例如,需要对有大量对象的list进行排序,在TimerTask中执行不会阻塞子线程,常常与handler结合使用,在处理完复杂耗时的操作后,通过handler来更新UI界面。

    timer.schedule(task,delay,period);

    task: TimerTask类型的对象,实现TimerTask的run()方法就是要周期执行的一个任务;

    delay : 从定时器初始化成功 开始启动 的延迟时间。

    period:定时器的间隔时间。

    第三个参数就是执行的周期,为long类型。

    TimerTask task= new TimerTask() {

    @Override

    public void run() {

    count++;

    Log.i("MainActivity",count + "");

    }

    };

    new Timer().shedule(task,1000);//

    以下是几种调度task的方法:

    //time为Date类型:在指定时间执行

    timer.schedule(task,time);

    //firstTime为Date类型,period为long,表示从firstTime时刻开始,每隔period毫秒执行一次。

    timer.schedule(task,firstTime,period);

    //delay 为long类型:从现在起过delay毫秒执行一次。

    timer.schedule(task,delay);

    //delay为long,period为long:从现在起过delay毫秒以后,每隔period毫秒执行一次。

    timer.schedule(task,period);

    //time为Date类型:在指定时间执行一次。

    timer.schedule(task,period);

    注意: 1.taskonDestory()中取消掉,否则可能发生崩溃

    2.用TimerTask定时进行某些操作的APP,即使退出了,TimerTask中依然会运行一会,但是不能长时间运行

    3.对于部分手机,如果你在TimerTask直接更新了UI线程是不会报错的,而且运行正常,但是一定注意,更新UI一定要在主线程中执行,否则排查错误的时候你懂得。而且这个东西特别耗电,特别耗电,特别耗电,重要的事情说三遍,一定在不使用的时候关闭

    二 、CountDownTimer

    CountDownTimer cdt = new CountDownTimer(10000,100) {

    @Override

    public void onTick(long millisUntilFinished) {

    tv_hello.setText(millisUntilFinished + "");

    }

    @Override

    public void onFinish() {

    }

    };

    cdt.start();

    onTick中的方法一次

    直到执行完10000/100次为止,最后会执行onFinish()

    三、 AlarmManager

    Intent intent2 = newIntent(ReadLogService.this,TestBroadcast.class);

    PendingIntent pd=PendingIntent.getBroadcast(getApplicationContext(),intent2,PendingIntent.FLAG_ONE_SHOT);

    AlarmManager am = (AlarmManager)getSystemService(ALARM_SERVICE);

    long triggerTime =SystemClock.elapsedRealtime() + 5*1000;

    am.set(AlarmManager.ELAPSED_REALTIME,triggerTime,pd);

    上面就是定时器的基本用法,先获取manager,然后定义闹钟的flag,循环时间,到指定时间发出的pendingIntent。

    一般都发出的pendingIntent都是广播,我们自定义一个广播接收器,就可以通过接收这个广播,来处理自己的功能逻辑了。

    这里需要注意在独立进程中配置,这是android所定义的

    1,Alarm定时不需要程序自身去维护,而又系统来维护,使得程序更好避免了容易出错问题,更是占用系统资源,cpu占有率。

    2,即使程序退出后,程序自身不会有任何烦恼的问题,系统到时间自动调用对应组件执行定义好的逻辑

    3,定时的多样性,包括一次定时,循环定时(在xx年x月x日执行,周一至周五执行,每天几点几分执行。。。)

    四、 handler

    Handler可以帮助我们在子线程中操作UI线程,例如子线程解析数据,解析结束后通知UI刷新界面。他本身也可以实现定时器。

    private Handler handler = Handler() {

    public handleMessage(android.os.Message msg) {

    switch (msg.what) {

    :

    // 移除所有的msg.what为0等消息,保证只有一个循环消息队列再跑

    handler.removeMessages();

    // app的功能逻辑处理

    ...

    // 再次发出msg,循环更新

    handler.sendEmptyMessageDelayed(,);

    break;

    :

    // 直接移除,定时器停止

    handler.removeMessages();

    break;

    default:

    break;

    }

    };

    };

    只要在启动定时器的时候,Handler.sendEmptyMessage(0),定时器就启动了。继续循环和停止的方法,注释上已经写了。

    每次循环都是在主线程中操作,避免了子线程和主线程之间的穿插交互,个人觉得比timer好控制,功能实现也很简单。

    个人觉得比较适用连续更新UI,不做复杂耗时的处理的情况,例如在播放器中,我们需要更新当前播放进度的时间的显示,仅仅是更新了文字显示,用handler就是个不错的选择。

    五、Thread

    Thread实现定时器是创建一个子线程,在里面while循环,可以通过handler来更新UI。个人觉得Thread和Timer没区别,只是长得不一样。

    private MyThread thread;

    private class MyThread extends Thread {

    public boolean stop;

    public () {

    while (!stop) {

    // 处理功能

    // 通过睡眠线程来设置定时时间

    {

    Thread.sleep();

    } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    };

    };

    /**

    * 启动线程

    * */

    private start() {

    (thread == ) {

    thread = MyThread();

    thread.start();

    }

    }

    /**

    * 停止线程

    * */

    private () {

    (thread != ) {

    thread.stop = ;

    thread = ;

    }

    }

    觉得跟Timer差不多,没什么特殊优点

    跟Timer差不多,多线程如果考虑不周经常会出问题,经常会出现多个相同功能的线程同时存在,android本身对于子线程的使用使用数量是有限制的,而且一个app同时跑多个线程是一个很可怕的事情,所以和Timer一样,使用的时候一定要谨慎考虑。

    以上所述是小编给大家介绍的Android实现定时器的五种方法实例详解,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对编程小技巧网站的支持!

    总结

    如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给程序员好友。

    本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。

    小编个人微信号 jb51ccc

    喜欢与人分享编程技术与工作经验,欢迎加入编程之家官方交流群!

    展开全文
  • Android 定时器.pdf

    2021-08-09 18:55:22
    Android 定时器.pdf

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,873
精华内容 8,749
关键字:

定时器android