Android实现定时器

1.单独使用handler实现定时器，这种实现方法是在主线程中操作，只有在耗时比较少的时候才会有效，并且如果间隔时间太短，可能并不会起作用。

Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 1) {
                //需要更新的操作
                ...
                //移除msg.what=1的消息，使消息队列中只有一个循环消息
                handler.removeMessages(1);
                //间隔1秒后，重新发送msg=1的消息
                handler.sendEmptyMessageDelayed(1,1000);
            }
            else if (msg.what == 0){
            //直接移除消息，定时器停止
                handler.removeMessages(1);
            }
            super.handleMessage(msg);
        }
    };
 public void start() {
            Message msg=new Message();
            msg.what = 1;
            handler.sendMessage(msg);

    }
    // 停止
    public void stop() {
            Message msg=new Message();
            msg.what = 0;
            handler.sendMessage(msg);

    }

2.handler中的postDelayed(),前面一个参数是操作的对象，后面一个参数是需要更新的时间

    Handler handler = new Handler();
    Runnable runnable = new Runnable() {

        @Override
        public void run() {
            // handler自带方法实现定时器
            try {
                //需要更新的操作
               ...
                handler.postDelayed(this, 13);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    };

    //启动
    public void start() {
        // 将线程接口立刻送到线程队列中
        handler.post(runnable);
        this.invalidate();

    }

    //停止
    public void stop() {
        // 将接口从线程队列中移除
        handler.removeCallbacks(runnable);
    }

3.handler和Thread的组合，开启子线程，使用handler刷新UI

Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 1) {
               //需要实现的操作
                ...
            }
            super.handleMessage(msg);
        }
    };
// 线程类
class MyThread implements Runnable {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (flag) {
            try {
                //间隔时间
                Thread.sleep(200);
                Message msg = new Message();
                msg.what = 1;
                handler.sendMessage(msg);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
    Thread thread;
    // 启动
    public void start() {
        if (flag==false) {
            flag = true;
            //避免多次创建线程
            if (thread==null) {
                thread=new Thread(new MyThread());
                thread.start();
            }
        }
    }

    // 停止
    public void stop() {
        //当flag为true时，停止
        if (flag==true) {
            flag = false;
            if (thread!=null) {
                thread=null;
            }
        }
    }

4.handler和timer

Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            if (msg.what == 1) {
                //要实现的操作
                ...
                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);
        }
    };

    public void start() {
//经过10ms执行task，然后再经过100ms再次执行
        timer.schedule(task, 10, 100);
    }

    // 停止
    public void stop() {
        //取消后不能重新启动，若要重新启动，需要新建一个task
        timer.cancel();
    }