android消息处理的N种方式

转载请注明出处：https://blog.csdn.net/u011038298/article/details/88887951 

import android.app.Activity;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.MessageQueue;
import android.widget.Toast;

import java.lang.ref.WeakReference;

public class Test {

    public void method1() {
        // 使用Handler后台空闲线程IdleHandler去加载耗时任务
        Looper.myQueue().addIdleHandler(new MessageQueue.IdleHandler() {
            @Override
            public boolean queueIdle() {
                // IdleHandler是在handler空闲的时候进行处理。如果返回true,则会一直执行，如果返回false，执行完一次后就会被移除消息队列，后续不再监听
                return false;
            }
        });
    }

    public void method2(final Context context) {
        // 如果线程中使用Looper.prepare()和Looper.loop()创建了消息队列就可以让消息处理在该线程中完成
        new Thread(new Runnable() {
            @Override
            public void run() {
                /**
                 * 将当前线程初始化为looper。
                 * 调用 prepare()运行循环的线程，然后 loop()让它处理消息，直到循环停止。
                 */
                Looper.prepare();
                // 执行弹窗
                Toast.makeText(context, "消息弹窗", Toast.LENGTH_LONG).show();
                /**
                 * 在此线程中运行消息队列。
                 * 写在Looper.loop()之后的代码不会被执行，这个函数内部是一个循环，
                 * 当调用Handler.getLooper().quit()之后，loop才会中止，其后的代码才会运行。
                 */
                Looper.loop();
            }
        }).start();
    }

    public void method3() {
        Runnable callbackRunnable = new Runnable() {
            @Override
            public void run() {
                // 在主线程中执行任务
            }
        };
        if (Looper.getMainLooper() == Looper.myLooper()) {
            // 如果是主线程
            callbackRunnable.run();
        } else {
            // 如果不是主线程
            new Handler(Looper.getMainLooper()).post(callbackRunnable);
        }
    }

    public void method4(Activity activity) {
        /**
         * 程序首先会判断当前线程是否是UI线程，如果是就直接运行，如果不是则post，本质还是使用Handler机制来处理线程与UI通讯
         */
        activity.runOnUiThread(new Runnable() {
            @Override
            public void run() {

            }
        });
    }

    public void method5(Activity activity) {
        MyHandler myHandler = new MyHandler(activity);
        // 发送一个空消息
        myHandler.sendEmptyMessage(0);
        // 发送一个带对象的消息(使用obtain避免创建多个Message)
        Message message = Message.obtain();
        message.obj = "";
        message.what = 1;
        myHandler.sendMessage(message);
        // 退出Activity时，在onDestroy中执行,避免内存泄漏
        myHandler.removeCallbacksAndMessages(null);
    }

    /**
     * Handler使用，避免内存泄漏
     * 在Java 中，非静态的内部类和匿名内部类都会隐式地持有其外部类的引用，静态的内部类不会持有外部类的引用
     */
    private static class MyHandler extends Handler {

        private WeakReference<Activity> mWeakReference;

        public MyHandler(Activity activity) {
            mWeakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            final Activity activity = mWeakReference.get();
            if (activity != null) {
                switch (msg.what) {
                    case 0:
                        break;
                    case 1:
                        break;
                }
            }
        }
    }

    public void method6() {
        // 异步任务
        if (mAsyncTask == null) {
            mAsyncTask = new MyAsyncTask();
        }
        // 如果没有在运行，则启动异步任务，避免重复执行
        if (mAsyncTask.getStatus() != AsyncTask.Status.RUNNING) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
                new MyAsyncTask().executeOnExecutor(
                        AsyncTask.THREAD_POOL_EXECUTOR);
            } else {
                new MyAsyncTask().execute();
            }
        }
    }

    // 异步任务
    private MyAsyncTask mAsyncTask;

    private class MyAsyncTask extends AsyncTask<String, Integer, String> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            // 准备执行
        }

        @Override
        protected String doInBackground(String... strings) {
            // 后台执行(子线程)
            return "";
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            // 返回结果(主线程)
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
            // 任务取消
        }

    }

}