Android消息机制——Handler

 

 

/**android的消息处理有三个核心类：Looper，Handler和Message。其实还有一个MessageQueue（消息队列），
 * 但是MessageQueue被封装到Looper里面了。
 *
 * Looper
 *
 * Looper  循环着。被设计用来使一个普通线程变成Looper线程。
 *         Looper.prepare()将当前线程初始化为Looper线程
 *         ....实例化Handler，处理消息
 *         Looper.loop()开始循环处理消息队列。调用后开始不断从Looper内部的消息队列中取出消息执行
 *
 * 注意：Looper.loop()之后的方法不会再执行到。一个Thread只能有一个Looper对象
 * Looper类还有一些方法：Looper.myLooper()得到当前线程looper对象
 *                      Looper.getThread()得到looper对象所属线程
 *                      Looper.quit()结束looper循环
 *
 *
 * Handler
 *
 * Handler扮演了往MessageQueue上添加消息和处理消息的角色（只处理由自己发出的消息）。
 * 即通知MessageQueue它要执行一个任务（sendMessage），并在循环到自己的时候执行该任务（handleMessage）,整个过程是异步的。
 * Handler创建时会关联一个Looper，默认构造方法将关联当前线程的looper.
 *
 * 一个线程可以有多个Handler,但只能有一个Looper.
 *
 *拿到handler引用之后，我们就可以使用它的方法。比如：
 *      post(Runnable) //其实post发出的Runnable对象最后都被封装成Message对象了
 *      postAtTime(Runnable,long)
 *      postDelayed(Runnable,long)
 *      sendEmptyMessage(int)
 *      sendMessage(Message)
 *      sendMessageAtTime(Message,long)
 *      sendMessageDelayed(Message,long)
 *
 *
 *  Message类
 *  Message被存放在MessageQueue中，一个MessageQueue中可以包含多个Message对象。
 *  Message中包含两个额外的int字段和一个Object字段。
 *      Message.arg1 /Message.arg2  存放整形数据
 *      Message.obj   存放发送给接收器的Object类型的任意对象
 *      Message.what  用来指定用户自定义的消息代码
 *
 *  使用Message.obtain()或Handler.obtainMessage()函数来获取Message对象
 *
 *
 *  异步消息处理的流程：
 *  首先需要在主线程当中创建一个Handler对象，并重写handlerMessage()方法。
 *  然后当子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler将这条消息发送出去。
 *  之后这条消息会被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出待处理的消息，
 *  最后分发回Handler的handlerMessage()方法中。
 *  由于Handler是在主线程中创建的，所以此时handlerMessage()方法中的代码也会在主线程中运行，所以可以安心在这里更新UI
 *
 *
 *
 */


public class MainActivity extends AppCompatActivity {

    ViewPager viewPager;
    Button btn_start;
    List<Fragment> mList = new ArrayList<>();

    Handler mainHandler, childHandler;

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


    }

    private void initView() {
        viewPager = (ViewPager) findViewById(R.id.viewpager);
        btn_start = (Button) findViewById(R.id.btn_start);

        initData();

        FragmentManager fm = getSupportFragmentManager();
        //如果使用PagerAdapter，需要重写instantiateItem()加载视图，onDestroy()销毁视图
        //FragmentPagerAdapter，每一个生成的Fargment都保存在内存中，也就是FragmentManaer中，就算刷新Adapter，还是使用的上次缓存的Fragment
        //FragmentStatePagerAdapter的instantiateItem()加载视图的时候会每次重新创建Fragment。
        viewPager.setAdapter(new FragmentStatePagerAdapter(fm) {
            @Override
            public Fragment getItem(int position) {
                return mList.get(position%6);
            }

            @Override
            public int getCount() {
                return Integer.MAX_VALUE;
            }
        });
        viewPager.setCurrentItem(0);

        //主线程接收子线程消息并处理
        mainHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Log.e("TAG", "最终处理" + (int) msg.obj);
                viewPager.setCurrentItem((int) msg.obj);

                if (childHandler != null) {
                    Message toChild = childHandler.obtainMessage();
                    toChild.obj = msg.obj;
                    childHandler.sendMessageDelayed(toChild, 500);
                }
            }
        };

        new myThread().start();

        //点击开始轮播图片
        btn_start.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (childHandler != null) {
                    Message firstMsg = childHandler.obtainMessage();
                    firstMsg.obj = viewPager.getCurrentItem();
                    childHandler.sendMessageDelayed(firstMsg, 500);
                }
            }
        });

    }

    class myThread extends Thread {

        @Override
        public void run() {
            Looper.prepare();//初始化消息队列，必须在创建Handler之前
            Log.e("TAG", "************");

            childHandler = new Handler() {
                @Override
                public void handleMessage(Message msg) {
                    Message toMain = mainHandler.obtainMessage();
                    toMain.obj = (int)msg.obj + 1;
                    Log.e("TAG", "toMain obj " + (int) (toMain.obj));
                    mainHandler.sendMessageDelayed(toMain, 500);
                }
            };

            //启动子线程消息队列
            Looper.loop();

        }
    }



    @Override
    protected void onDestroy() {
        Log.e("TAG","@@@@@@@@@@@@@@@@@onDestroy");
        childHandler.getLooper().quit();
        super.onDestroy();
    }

    private void initData() {
        mList.add(new OneFragment());
        mList.add(new TwoFragment());
        mList.add(new ThreeFragment());
        mList.add(new FourFragment());
        mList.add(new FiveFragment());
        mList.add(new SixFragment());
    }
}

 

 

 

 

public class OneFragment extends Fragment {
    TextView tv;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        return View.inflate(getContext(),android.R.layout.simple_list_item_1,null);
    }


    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        tv = (TextView) view.findViewById(android.R.id.text1);
        tv.setBackgroundResource(R.mipmap.img01);
    }
}

 

 

Handler的工作机制简单来说是这样的

1、Handler发送消息仅仅是调用MessageQueue的enqueueMessage向插入一条信息到MessageQueue

2、Looper不断轮询调用MeaasgaQueue的next方法

3、如果发现message就调用handler的dispatchMessage，ldispatchMessage被成功调用，接着调用handlerMessage()

简图

 

参考：

http://www.jianshu.com/p/9e4d1fab0f36

http://blog.csdn.net/thanklife/article/details/16993085