Android Handler及后台任务

事件处理，采用委派式事件处理方式。
1.基于监听事件处理
    1).获取界面组件(事件源)，即监听对象
    2).实现事件监听器类，一个XxxListener接口。
    3).调用事件源的setXxxListener将将监听器对象注册给事件源。
    
    事件监听器，通常有：
    内部类；外部类；Activity本身作为事件监听器类；匿名内部类
    直接绑定到标签
    
2.基于回调事件处理
    Android为所有GUI组件都提供了一些事件处理的回调方法。如onKeyUp(), onKeyDown()等
    几乎所有回调事件处理方法都有一个boolean类型的返回值，标识该方法是否能完全处理该事件。
    如果为true，则不传播出去，否则传播出去。
    
基于监听的事件处理模型优势：
    1.分工更明确，事件源、事件监听器分开，更好可维护性
    2.事件机制保证基于监听的事件监听器优先触发
    
Handler类作用：
    新启动的线程中发送消息；
    主线程中获取、处理消息。
当新启动的线程发送消息时，消息发送给MessageQueue，而handler不断从MessageQueue中
获取并处理消息--这导致Handler类中消息处理方法被回调。主要方法有：
    void handleMessage(Message msg):处理消息的方法，长用于被重写
    final boolean hasMessages(int what):检查队列中是否包含what属性值消息
    final boolean hasMessages(int what, Object obj):检查队列中是否包含what属性值且obj指定对象消息
    多个重载的Message obtainMessage():获取空消息
    sendEmptyMessage(int what):发送空消息
    final boolean sendEmptyMessageDelayed(int what, long delayMillis):延迟发送
    final boolean sendMessage(Message msg):立即发送
    final boolean sendMessageDelayed(Message msg, long delayMillis):延迟发送
    
Message：Handler接受和处理的消息对象
Looper：每个线程只能拥有一个Looper，其loop负责读取MessageQueue中消息，读到消息后就发送该消息的Handler进行处理。
MessageQueue：消息队列，IFIO进行管理。当创建Looper时会在构造器中创建MessageQueue对象。
    
UI线程中，系统创建了looper对象，直接使用handler即可。
另外新建的线程需要创建Looper对象并启动她，使用prepare()即可。步骤为：
    1).调用Looper的prepare()方法为当前线程创建Looper对象，构造器会创建与之匹配的MessageQueue
    2).创建Handler实例，重写handleMessage(),负责处理来自其它线程的消息。
    3).调用Looper的loop()启动Looper
    

    public void cal(View source)
	{
		// 创建消息
		Message msg = new Message();
		msg.what = 0x123;
		Bundle bundle = new Bundle();
		bundle.putInt(UPPER_NUM ,
				Integer.parseInt(etNum.getText().toString()));
		msg.setData(bundle);
		// 向新线程中的Handler发送消息
		calThread.mHandler.sendMessage(msg);
	}

 

    class CalThread extends Thread
    {
        public Handler mHandler;
        public void run()
        {
            Looper.prepare(); //1
            mHandler = new Handler()//2
            {
                // 定义处理消息的方法
                @Override
                public void handleMessage(Message msg)
                {
                    if(msg.what == 0x123)
                    {
                        int upper = msg.getData().getInt(UPPER_NUM);
                        List<Integer> nums = new ArrayList<Integer>();
                        // 计算从2开始、到upper的所有质数
                        outer:
                        for (int i = 2 ; i <= upper ; i++)
                        {
                            // 用i除以从2开始、到i的平方根的所有数
                            for (int j = 2 ; j <= Math.sqrt(i) ; j++)
                            {
                                // 如果可以整除，则表明这个数不是质数
                                if(i != 2 && i % j == 0)
                                {
                                    continue outer;
                                }
                            }
                            nums.add(i);
                        }
                        // 使用Toast显示统计出来的所有质数
                        Toast.makeText(MainActivity.this, nums.toString()
                            , Toast.LENGTH_LONG).show();
                    }
                }
            };
            Looper.loop();
        }
    }

AsyncTask是一个抽象类，包含三个参数：
第一个：启动任务执行的输入参数的类型
第二个：后台任务完成得进度值的类型
第三个：后台执行任务完成后返回结果类型

使用步骤：
    1).创建AsyncTask子类，并为三个泛型参数指定类型。
    2).根据需要实现方法：
    doInBackground(para...):后台线程要完成的任务。可以调用publishProgress(values)更新进度
    onProgressUpdate(values)：在doInBackground中调用publishProgress触发
    onPreExecute():执行后台耗时操作前被调用，通常用于完成一些初始化准备工作。
    onPostExecute(Result result):当doInBackground完成后，将返回值传给此方法，并且系统自动调用此方法
    3).调用AsyncTask之类的实例execute(para...)开始执行耗时任务
AsyncTask只能执行一次，多次调用会引发异常。