Android handler / 循环定时执行任务 / Timer开启循环任务

已于 2023-08-02 21:04:58 修改
阅读量1.3k 收藏
点赞数
分类专栏： android 文章标签： android
于 2023-03-13 20:14:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42015021/article/details/129504848
版权

Handler概念

Handler允许你发送和处理Message和Runnable object通过关联的一个线程的MessageQueue.

Handler线程间传递消息机制

调用示例1

主函数

 myThread = new MyThread();
 Message message = mHandler.obtainMessage();
 message.what = 1;
 mHandler.sendMessage(message);

线程类 MyThread

线程类一创建，就会实例化MyHandler，线程创建后使用start(),线程就启动了吗？

private class MyThread{

        public MyThread() {
            final HandlerThread thread =
                    new HandlerThread("myThread",
                            Thread.MIN_PRIORITY);
            thread.start();
            mHandler = new MyHandler(thread.getLooper());
        }

        private class MyHandler extends Handler{
            public MyHandler(Looper looper) {
                super(looper);
            }
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what){
                    case 1:
                        try {
                            Log.i(TAG, "handleMessage: " + msg.what);
                            String str = URLDecoder.decode(msg.obj.toString(), "UTF-8");
                            Log.d(TAG, "handleMessage: " + str);
                        } catch (Exception e) {
                            Log.e(TAG,e.getMessage());
                            e.printStackTrace();
                        }
                        break;
                }
            }

        }
    }

测试结果

2023-04-04 20:31:22.181 28448-32076/cn.jj.restart I/JJWorld: handleMessage: 1
2023-04-04 20:31:22.181 28448-32076/cn.jj.restart E/JJWorld: Attempt to invoke virtual method 'java.lang.String java.lang.Object.toString()' on a null object reference

线程间通信 Handler与读写锁对比1

Handler每秒传输120次消息 通过读写锁每秒传输120次消息对比。

RandomStringUtils工具类来自于此库 implementation ‘org.apache.commons:commons-lang3:3.7’

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private MyThread myThread;
    private Handler mHandler;
    private String TAG = "JJWorld";
    private Button button;
    private int interval = 0;
    private int interval2 = 0;
    private ArrayList<String> list = new ArrayList<String>();
    private ArrayList<String> list2 = new ArrayList<String>();
    private ReentrantReadWriteLock readWriteLock =new ReentrantReadWriteLock();
    private Button button2;
    private Integer period = 8;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        myThread = new MyThread();
        Message message = mHandler.obtainMessage();
        message.what = 1;
        message.obj = 1;
        mHandler.sendMessage(message);
        initView();
        button.setOnClickListener(this);
        button2.setOnClickListener(this);
    }

    private void initView() {
        button = (Button) findViewById(R.id.button);
        button2 = (Button) findViewById(R.id.button2);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button:
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        interval++;
                        Message message = mHandler.obtainMessage();
                        message.what = 1;
                        message.obj = interval + RandomStringUtils.random(15);
                        mHandler.sendMessage(message);
                    }
                }, 0, period);
                break;
            case R.id.button2:
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        try {
                            readWriteLock.writeLock().lock();
                            list2.add(String.valueOf(interval2++ + RandomStringUtils.random(15)));
                            if (list2.size() >= 60){
                                Message message = mHandler.obtainMessage();
                                message.what = 2;
                                message.obj = list2;
                                mHandler.sendMessage(message);
                            }
                        }catch (Exception e){

                        }finally {
                            readWriteLock.writeLock().unlock();
                        }

                    }
                }, 0, period);
                break;
        }


    }

    private class MyThread {

        public MyThread() {
            final HandlerThread thread =
                    new HandlerThread("myThread",
                            Thread.MIN_PRIORITY);
            thread.start();
            mHandler = new MyHandler(thread.getLooper());
        }

        private class MyHandler extends Handler {
            public MyHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                    case 1:
                        try {
                            list.add(msg.obj.toString());
                            if (list.size() >= 60) {
                                Log.d(TAG, "list: " + list);
                                list.clear();
                            }
                        } catch (Exception e) {
                            Log.e(TAG, e.getMessage());
                            e.printStackTrace();
                        }
                        break;
                    case 2:
                        try {
                            readWriteLock.readLock().lock();
                            Log.d(TAG, "list: " + list2);
                            list2.clear();
                        } catch (Exception e) {
                            Log.e(TAG, e.getMessage());
                            e.printStackTrace();
                        }finally {
                            readWriteLock.readLock().unlock();
                        }
                        break;
                }
            }

        }
    }
}

结论

使用读写锁CPU使用率稳定于 0%-1%；
使用Handler进行传输消息，CPU使用率稳定与 1%-2%；

Handler

在这里插入图片描述

读写锁

在这里插入图片描述

线程间通信 Handler与读写锁对比2

handler和锁方式性能消耗接近。
加锁情况下，创建两个线程分别每4ms修改一次NotNeedCollectData中的userId与game_scene参数，创建两外一个线程每20ms读取一次NotNeedCollectData中的userId与game_scene，CPU使用率大约为2%-3%;
使用Hanler进行消息传递，创建两个线程分别每4ms传递一次userId与game_scene参数，创建两外一个线程每20ms读取一次userId与game_scene，CPU使用率大约为3%;

测试程序如下：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private MyThread myThread;
    private Handler mHandler;
    private String TAG = "JJWorld";
    private Button button4;
    private Button button5;
    private Button button;
    private Button button2;
    private Button button3;
    private NotNeedCollectData notNeedCollectData;
    private int period = 4;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        myThread = new MyThread();
        Message message = mHandler.obtainMessage();
        message.what = 1;
        message.obj = 1;
        mHandler.sendMessage(message);
        initView();
        button4.setOnClickListener(this);
        button5.setOnClickListener(this);
        notNeedCollectData = new NotNeedCollectData();
        button.setOnClickListener(this);
        button2.setOnClickListener(this);
        button3.setOnClickListener(this);
    }

    private void initView() {
        button4 = (Button) findViewById(R.id.button4);
        button5 = (Button) findViewById(R.id.button5);
        button = (Button) findViewById(R.id.button);
        button2 = (Button) findViewById(R.id.button2);
        button3 = (Button) findViewById(R.id.button3);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button4:
                mHandler.sendEmptyMessage(4);
                break;
            case R.id.button5:
                mHandler.sendEmptyMessage(5);
                break;
            case R.id.button:
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        notNeedCollectData.setUserid("time:" + String.valueOf(System.currentTimeMillis()));
                    }
                }, 0, period);
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        notNeedCollectData.setGame_scene("scene:" + String.valueOf(System.currentTimeMillis()));
                    }
                }, 0, period);
                break;
            case R.id.button2:
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        Message message = mHandler.obtainMessage();
                        message.what = 6;
                        message.obj = String.valueOf(System.currentTimeMillis());
                        mHandler.sendMessage(message);
                    }
                }, 0, period);
                new Timer().schedule(new TimerTask() {
                    @Override
                    public void run() {
                        Message message = mHandler.obtainMessage();
                        message.what = 7;
                        message.obj = String.valueOf(System.currentTimeMillis());
                        mHandler.sendMessage(message);
                    }
                }, 0, period);
                break;
            case R.id.button3:
                mHandler.sendEmptyMessage(8);
                break;
        }


    }

    private class MyThread {
        public MyThread() {
            final HandlerThread thread =
                    new HandlerThread("jjThread",
                            Thread.MIN_PRIORITY);
            thread.start();
            mHandler = new MyHandler(thread.getLooper());
        }
        private String time;
        private String scene;

        private Runnable runnable = new Runnable() {
            @Override
            public void run() {
                mHandler.postDelayed(this, period * 5);
                Log.i(TAG, "time:" + notNeedCollectData.getUserid() + " scene:" + notNeedCollectData.getGame_scene());
            }
        };

        private Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                mHandler.postDelayed(this, period * 5);
                Log.i(TAG, "time:" + time + " scene:" + scene);
            }
        };

        private class MyHandler extends Handler {
            public MyHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                    case 4:
                        mHandler.post(runnable);
                        break;
                    case 5:
                        mHandler.removeCallbacks(runnable);
                        break;
                    case 6:
                        time = (String) msg.obj;
                        break;
                    case 7:
                        scene = (String) msg.obj;
                        break;
                    case 8:
                        mHandler.post(runnable2);
                        break;
                    default:

                }
            }

        }
    }
}

结果

Handler性能消耗 3%左右

在这里插入图片描述

锁性能消耗 2-3%左右
在这里插入图片描述

HandlerThread与Thread的区别

HandlerThread 内部实现了 Looper，不用再调用Looper.prepare()和Looper.loop()这些方法。
Thread需要手动调用Looper.prepare()和Looper.loop()方法。

Handler循环定时执行任务

mHandler.sendEmptyMessageDelayed(4,2000) 方式

使用mHandler.sendEmptyMessage(4)与mHandler.sendEmptyMessageDelayed(4,2000) 可以实现程序的循环执行，但是无法终止程序。

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private MyThread myThread;
    private Handler mHandler;
    private String TAG = "JJWorld";
    private Button button4;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        myThread = new MyThread();
        Message message = mHandler.obtainMessage();
        message.what = 1;
        message.obj = 1;
        mHandler.sendMessage(message);
        initView();
        button4.setOnClickListener(this);

    }

    private void initView() {
        button4 = (Button) findViewById(R.id.button4);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {

            case R.id.button4:
                mHandler.sendEmptyMessage(4);
                break;
        }
    }

    private class MyThread {
        public MyThread() {
            final HandlerThread thread =
                    new HandlerThread("jjThread",
                            Thread.MIN_PRIORITY);
            thread.start();
            mHandler = new MyHandler(thread.getLooper());
        }

        private class MyHandler extends Handler {
            public MyHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                    case 4:
                        Log.i(TAG, "time: " + System.currentTimeMillis());
                        mHandler.sendEmptyMessageDelayed(4,2000);
                        break;
                }
            }

        }
    }
}

mHandler.post(runnable) 方式

通过mHandler.post(runnable) 以及 mHandler.removeCallbacks(runnable)实现代码的循环与重启。

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private MyThread myThread;
    private Handler mHandler;
    private String TAG = "JJWorld";
    private Button button4;
    private Button button5;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        myThread = new MyThread();
        Message message = mHandler.obtainMessage();
        message.what = 1;
        message.obj = 1;
        mHandler.sendMessage(message);
        initView();
        button4.setOnClickListener(this);
        button5.setOnClickListener(this);
        
    }

    private void initView() {
        button4 = (Button) findViewById(R.id.button4);
        button5 = (Button) findViewById(R.id.button5);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button4:
                mHandler.sendEmptyMessage(4);
                break;
            case R.id.button5:
                mHandler.sendEmptyMessage(5);
                break;
        }


    }

    private class MyThread {
        private Runnable runnable = new Runnable() {
            @Override
            public void run() {
                mHandler.postDelayed(this, 2000);
                // TODO Auto-generated method stub
                Log.i(TAG, "thread " + Thread.currentThread().getName());
                //要做的事情，这里再次调用此Runnable对象，以实现每两秒实现一次的定时器操作
                Log.e(TAG, "case 4:" + System.currentTimeMillis());
            }
        };
        
        public MyThread() {
            final HandlerThread thread =
                    new HandlerThread("jjThread",
                            Thread.MIN_PRIORITY);
            thread.start();
            mHandler = new MyHandler(thread.getLooper());
        }
        
        private class MyHandler extends Handler {
            public MyHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                    case 4:
                        mHandler.post(runnable);
                        break;
                    case 5:
                        mHandler.removeCallbacks(runnable);
                        break;
                }
            }

        }
    }
}

Timer开启循环任务

Timer本身会开启线程：

new Timer().schedule(new TimerTask() {
    @Override
    public void run() {
        notNeedCollectData.setUserid("time:" +String.valueOf(System.currentTimeMillis()));
    }
}, 0, period);
学知识拯救世界
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android使用Handler实现定时器与倒计时器功能
01-05
什么是Handler     Handler是Android消息机制的上层接口，它为我们封装了许多底层的细节，让我们能够很方便的使用底层的消息机制。Handler的最常见应用场景之一便是通过Handler在子线程中间接更新UI。Handler的作用主要有两个：一是发送消息；二是处理消息，它的运作需要底层Looper和MessageQueue的支撑。MessageQueue即消息队列，它的底层用单链表实现；Looper则负责在一个循环中不断从MessageQueue中取消息，若取到了就交由Handler进行处理，否则便一直等待。关于Looper需要注意的一点是除了主线程之外的其他线程中默认是不存
Android Handler使用详解
小旭的专栏
01-07 6543
Handler负责发送消息，Looper负责接收Handler发送的消息，并直接把消息回传给handler自己，MessageQueue就是一个存储消息的容器。
Android中实现定时器的3种解决方法，大厂架构师经验分享
weixin_57992300的博客
03-25 972
我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了5、6年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
Android 定时任务过程详解
01-05
在Android开发中，通过以下三种方法定时执行任务： 一、采用Handler与线程的sleep(long)方法（不建议使用，java的实现方式） 二、采用Handler的postDelayed(Runnable, long)方法（最简单的android实现） 三、采用Handler与timer及TimerTask结合的方法(比较多的任务时建议使用) android里有时需要定时循环执行某段代码，或者需要在某个时间点执行某段代码，这个需求大家第一时间会想到Timer对象，没错，不过我们还有更好的选择。  一、Timer 实现定时任务 Timer timer; void onCreate(
Android 使用ViewPager自动滚动循环轮播效果
01-20
对Android 利用ViewPager实现图片可以左右循环滑动效果，感兴趣的朋友可以直接点击查看内容详情。 主要介绍如何实现ViewPager自动播放，循环滚动的效果及使用。顺便解决ViewPager嵌套(ViewPager inside ViewPager)影响触摸滑动及ViewPager滑动速度设置问题。 先给大家展示下效果图，喜欢的朋友可以下载源码： 1、实现 没有通过ScheduledExecutorService或Timer定期执行某个任务实现，而是简单的通过handler发送消息去完成一次滚动，在完成一次滚动后发送另外一个delay的滚动消息，如此循环实现。自动滚动部分核心代
android 延时或重复执行任务
04-19
android 延时或重复执行任务 Timer使用， Handler , Thread , AlarmManager
Android中实现定时循环任务的方法
qq_46269365的博客
02-01 3719
Android中实现定时循环任务的方法。
Android开发中如何实现一个定时任务
star_nwe的博客
08-23 3100
协程可以用来简化异步编程和线程管理。协程是一种轻量级的线程，它可以在不阻塞线程的情况下挂起和恢复执行。协程安卓提供了一些扩展函数，可以用来创建和处理定时任务。其中，delay函数可以用来暂停协程的执行一段时间，可以用来实现倒计时或者周期性的定时任务。例如，以下代码可以实现一个10秒的倒计时，每隔1秒更新一次：
Android几种定时任务实现方式汇总
热门推荐
巧克力的专栏
08-30 1万+
Android开发当中，定时器的场景太多太多，比如过多久轮询一次业务需求，或者轮询网络以及多少秒的倒计时，记录一下给需要的人一些帮助Android中的定时任务一般有两种实现方式，一种是使用 Java API 里提供的 Timer 类，一种是使用 Android 的 Alarm 机制。这两种方式在多数情况下都能实现类似的效果，但 Timer 有一个明显的短板，它并不适用于那些需要长期在后台运行的定时任务。.........
Android 用Handler Timer 做循环任务
u012514113的专栏
05-21 2265
项目场景： 在做项目的过程，需要用到循环任务，属于整个功能的一个很小部分，真正急用的时候， 不能一下子写出来，真是觉得android的基本功不扎实，还是通过Demo的方式记录下来吧 文章内容比较基础，仅记录一下，供参考 【Demo简单需求】：每隔5秒中， 弹出“正在执行循环任务”的Toast 解决方案： 【方案一】：用Handler 来实现 public c......
Handler定时器
qq_45371893的博客
09-03 385
【代码】Handler定时器。
Android实现定时任务及闹钟
01-03
android中定时有很多种是实现，常见的Handler 与Thread的结合，handler.postDelayed ,以及要使用的AlarmManger 等都可以实现定时任务的执行，但是使用场景却大不相同，这里主要是怎么用AlarmManager实现定时任务。 涉及知识点： 1）BroadCastReceiver任务接收 2）CountDownTimer倒计时 3）AlertDialog 任务提醒 4）AlarmManager 定时任务 这里实现的需求时每天定时24点关机，有设备是定制系统，防止长时间的不关机导致应用的卡顿，在关机时并给用户以提示，如果无操作就自动关机。 第一步是实现简单布
lv-timer-handler放到main主循环运行
01-11
lv_timer_handler放到main主循环运行DSLogic-la-230111-114844.dsl
Android Handler之消息循环的深入解析
01-05
Handler是用于操作线程内部的消息队列的类。这有点绕，没关系，我们慢慢的来讲。前面Looper一篇讲到了Looper是用于给线程创建消息队列用的，也就是说Looper可以让消息队列(MessageQueue)附属在线程之内，并让消息队列循环起来，接收并处理消息。但，我们并不直接的操作消息队列，而是用Handler来操作消息队列，给消息队列发送消息，和从消息队列中取出消息并处理。这就是Handler的职责。Handler，Looper和MessageQueue是属于一个线程内部的数据，但是它提供给外部线程访问的接口，Handler就是公开给外部线程，与线程通讯的接口。换句话说，这三个东西都是
Android 异步任务 设置 超时使用handler更新通知功能
08-28
主要介绍了Android 异步任务 设置 超时使用handler更新通知,文中给大家提到了使用AsyncTask设置请求超时的注意事项，需要的朋友可以参考下
安卓 开启service每分钟执行一次任务 模拟定时 或者定时任务
01-03
再开始之前我们还是先介绍下service吧：此处用的是IntentService，至于和常规的service有什么区别呢? 有了Service为什么还要有个IntentService呢？ 原因如下: 1)Service默认运行在主线程中，IntentService运行在一个新的线程中 2)Service需要主动调用stopSelf()或stopService()服务才可以停止，IntentService运行完后自动停止 使用IntentService需要注意2点: 1)构造函数中一定要调用父类的有参构造函数 2)需要耗时处理的事情放在onHandleIntent(Intent intent)
Android --- 英文单引号用&apos；替换报错：does not contain a valid string resource
梁同学与Android
04-23 185
Android --- 英文单引号用&apos;替换报错：does not contain a valid string resource
安卓aab文件生成apk文件
最新发布
ma15991375491的博客
04-24 290
比如我们在手机上经常下载的的各种APP，其实一个Android应用程序的代码想要在Android设备上运行，必须先进行编译，然后被打包成为一个被Android系统所能识别的文件才可以被运行，而这种能被Android系统识别并运行的文件格式便是“APK”。一个APK文件内包含被编译的代码文件(.dex 文件)，文件资源（resources）， 原生资源文件（assets），证书（certificates），和清单文件（manifest file）严格来说，两者没有什么区别，后者是前者的一种升级版格式文件。
bugku ezbypass
m_de_g的博客
04-23 184
bugku ezbypass $++,$_++
Android ViewModel中使用Handler添加定时任务
05-30
在Android ViewModel中使用Handler添加定时任务，可以先在ViewModel中创建Handler对象，然后使用postDelayed()方法实现定时任务的逻辑。以下是示例代码： 1. 在ViewModel中创建Handler对象： ``` private Handler mHandler = new Handler(); ``` 2. 在ViewModel中添加一个启动定时任务的方法： ``` public void startTimer() { mHandler.postDelayed(mTimerRunnable, 1000); // 定时任务每秒执行一次 } private Runnable mTimerRunnable = new Runnable() { @Override public void run() { // 在这里执行定时任务的逻辑 mHandler.postDelayed(this, 1000); // 重复执行定时任务 } }; ``` 3. 在需要启动定时任务的Activity或Fragment中，在ViewModel中调用startTimer()方法即可。 4. 在Activity或Fragment销毁时，需要在ViewModel中添加一个停止定时任务的方法： ``` public void stopTimer() { mHandler.removeCallbacks(mTimerRunnable); } ``` 5. 在Activity或Fragment销毁时，需要在onDestroy()方法中调用ViewModel中的stopTimer()方法。 请注意，定时任务会在后台线程中执行，如果需要更新UI，需要使用Handler或者LiveData等机制来实现。此外，如果需要在定时任务中执行一些耗时的操作，建议使用单独的线程来执行，避免阻塞定时任务的执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学知识拯救世界

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值