android中的消息模型

Android 中消息模型           

    1.Android 中线程应用机制？
           1)耗时操作应在工作线程执行
            2)UI操作应在主线程执行。

     在android的实际应用中UI线程一般负责

     与用户交互，在执行一些相关业务操作时

     尽量不要阻塞主线程。

Android 中线程之间数据的传递通常要借助消息模型实现，在消息模型中涉及到的常用对象：
        1)Message (消息，数据的载体)
        2)MessageQueue(消息队列，存储多个消息)
        3)Looper(迭代器，迭代消息队列中的消息)
        4)Handler(消息处理对象，发送和处理消息)

这些对象的一些伪代码实现：

     class Message{
             Object obj;
           ......
      }
     class MessageQueue{
              LinkedBlockingQueue<Message> msgQ;
                  ......
     }
     class Looper{一个线程一个
             MessageQueue msgQ;一个looper对应一个msgQ
           private Looper(){}
           public static void prepare(){}
           public static Looper myLooper(){}
            void loop(){}//负责迭代
    }
     class Handler{发送和处理消息
           public void sendMessage(Message msg){}
          public void handleMessage(Message msg){}
          .......
      }

主线程在启动以后默认会创建一个Looper,Looper在创建时会创建一个消息队列，所以主主线程的Looper及消息队列不需要我们创建。

给谁发消息就获得与谁的Looper关联的handler.

      1)android中主线程默认有Looper，且只有一个Looper
      2)主线程默认有消息队列，此队列在Looper创建时创建的。
      3)android工作线程默认没有Looper，最多可以只有一个Looper
      4)android中的一个线程中可以创建多个 handler对象
      5)android中有哪个handler发送消息就由 哪个handler处理消息
      6)多个工作线程可以同时给主线程发消息

       mHandler=new Handler(){//默认关联当前线程的Looper
            public void handleMessage(Message msg) {
               switch (msg.what) {
                case 1:
                pBar.setVisibility(View.VISIBLE);
                pBar.setMax(10);break;
                case 2:
                pBar.setProgress(msg.arg1);break;
                case 3:
                pBar.setProgress(0);
                pBar.setVisibility(View.GONE);break;
            }
            };//重写此方法的目的是要处理消息
        };

      7)Handler关联的哪个线程的Looper，其重写的handleMessage(Message msg方法就在哪个线程执行，当无关联的Loooper时，则默认关联当前线程的Looper

AsyncTask Android中的 异步任务对象的简单应用

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    
    public void onClick01(View v){
        String path="/mnt/sdcard/big.jpg";
        new DownTask().
        execute(path);        //此值会传递给doInBackground
    }
    /**
     * 第一个泛型决定了asynctask类中execute方法及doinbackground方法的参数类型
     * */
    class DownTask extends
    AsyncTask<String, Void, Bitmap>{

        /**此方法运行在主线程，在doInBackground方法
         * 之前执行，通常用于一些初始化操作*/
        @Override
        protected void onPreExecute() {
            Log.i("TAG", "onPreExecute");
        }

        /**此方法运行在工作线程:可以在此方法中
         * 执行一些耗时操作*/
        @Override
        protected Bitmap doInBackground(
        String... params) {
            Log.i("TAG", "doInBackground");
            Log.i("TAG","params[0]"+params[0]);
            return null;
        }//此方法必须重写(父类中是抽象的)

        /**此方法运行在主线程，
         * 用于处理doInBackground方法
         * 的返回结果*/
        @Override
        protected void onPostExecute(Bitmap result) {
            Log.i("TAG", "onPostExecute");
        }
    }

}

Executor ePool=new ThreadPoolExecutor(
                        3,//corePoolSize
                        4, //maximumPoolSize
                        1,//keepAliveTime (非核心线程的空闲时间)
                        TimeUnit.SECONDS,//unit
                        new LinkedBlockingQueue<Runnable>(10),
                        factory);
        /
        //1)线程池创建以后会没有线程对象。
        //2)有任务要处理时才会创建线程对象
        /*当我们创建线程池以后，假如有任务要执行
                 此时就会创建新的线程去处理任务，只要
                 有新的任务,就会创建新的线程，直到线程
                 的数量等于corePoolSize，再来新的任务
                 会将任务存储到任务队列，假如任务数量
                 比较多，任务队列也满了，此时再创建新的线
                 程，但线程的数量不能超过maximumPoolSize。
         */