Looper分析。ThreadLocal有关

Class used to run a message loop for a thread. Threads by default do not have a message loop associated with them; to create one,

call prepare() in the thread that is to run the loop, and then loop() to have it process messages until the loop is stopped.

 class LooperThread extends Thread {
       public Handler mHandler;
       public void run() {
           Looper.prepare();
           mHandler = new Handler() {
               public void handleMessage(Message msg) {
                   // process incoming messages here
               }
           };
           Looper.loop();
       }
   }

(1)提出问题：正如上面所说， 一个线程默认是没有Looper用来处理message队列的。但为什么我们在主线程时又没有自己创建Looper呢？

 public class Looper {
     private static final String TAG = "Looper";
 
     // sThreadLocal.get() will return null unless you've called prepare().
     static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();      //（1）又见到了眼熟的ThreadLocal,里面存放的是每个线程的Looper
     private static Looper sMainLooper;  // guarded by Looper.class
 
     final MessageQueue mQueue;
     final Thread mThread;
     volatile boolean mRun;
 
     private Printer mLogging;
 
      /** Initialize the current thread as a looper.
       * This gives you a chance to create handlers that then reference
       * this looper, before actually starting the loop. Be sure to call
       * {@link #loop()} after calling this method, and end it by calling
       * {@link #quit()}.
       */
     public static void prepare() {
         prepare(true);
     }
 
     private static void prepare(boolean quitAllowed) {
         if (sThreadLocal.get() != null) {
             throw new RuntimeException("Only one Looper may be created per thread");
         }
         sThreadLocal.set(new Looper(quitAllowed));
     }
 
     /**
      * Initialize the current thread as a looper, marking it as an
      * application's main looper. The main looper for your application
      * is created by the Android environment, so you should never need
      * to call this function yourself.  See also: {@link #prepare()}
      */
     public static void prepareMainLooper() {
         prepare(false);
         synchronized (Looper.class) {
             if (sMainLooper != null) {
                 throw new IllegalStateException("The main Looper has already been prepared.");
             }
             sMainLooper = myLooper();                                                       //(2)为主线程的Looper赋值
         }
     }
 
     /** Returns the application's main looper, which lives in the main thread of the application.
      */
     public static Looper getMainLooper() {
         synchronized (Looper.class) {
             return sMainLooper;
         }
     }
 
     /**
      * Return the Looper object associated with the current thread.  Returns
      * null if the calling thread is not associated with a Looper.
      */
     public static Looper myLooper() {                                               //(3)为主线程Looper赋值的其实就是调用ThreadLocal的get()
         return sThreadLocal.get();
     }
 
 }

2.如果不知道ThreadLocal是什么意思，自己去查API,我没这么大气和你讲。

3.所以我们可以这样用：

 public class MainActivity extends Activity {
 
       private ProgressDialog mpDialog;
         private int mCount = 0;  
 
     private Handler handler = new Handler(){
 
         @Override
         public void handleMessage(Message msg) {
             //update UI
              System.out.println("----------update ui ok--------------"+Thread.currentThread().getId());   // Thread id 为1 说明在主线程中执行。
              System.out.println("message arg1 : "+ msg.arg1);                                        //因为这是主线程，所以可以在这时更新UI
             super.handleMessage(msg);
         }
     };
 
     private Thread downThread = new Thread(){
 
         @Override
         public void run() {          
 
              try{
                  while(mCount<=100){
                      mpDialog.setProgress(mCount++);
                      Thread.sleep(100);                                            //模拟下载过程
                  }
                  // This is essentially the same as calling dismiss(),
                  //but it will also call your DialogInterface.OnCancelListener (if registered).
                  mpDialog.cancel();
                  System.out.println("------------download ok----------");
                  Message message = handler.obtainMessage();
                  message.arg1 = 10;
                  handler.sendMessage(message);
              }catch(Exception ex){
                  mpDialog.cancel();
              }
         }
 
     };
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         Button button= (Button) this.findViewById(R.id.button);
         imageView = (ImageView) this.findViewById(R.id.imageView01);
         button.setOnClickListener(new OnClickListener(){
 
             @Override
             public void onClick(View view) {
                     System.out.println("--------------download start----------------"+Thread.currentThread().getId());   //主线程的id为1
                     mCount = 0;
                     mpDialog = new ProgressDialog(MainActivity.this);
                     mpDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
                     mpDialog.setTitle("dialogʾ");
                     mpDialog.setIcon(R.drawable.ic_launcher);
                     mpDialog.setMessage("好消息");
                     mpDialog.setMax(100);
                     mpDialog.setProgress(0);
                     mpDialog.setSecondaryProgress(50);
                     mpDialog.setIndeterminate(false);
                     mpDialog.setCancelable(true);
                     mpDialog.setButton("取消", new DialogInterface.OnClickListener(){  
 
                         @Override
                         public void onClick(DialogInterface dialog, int which) {
                             dialog.cancel();  
 
                         }  
 
                     });
                     downThread.start();
                     mpDialog.show();
             }
 
         });
     }
 
 }

4.正如上面所说，一个新线程在默认情况下是没有Looper相关联的。所以需要自己创建。但android提供了一个HandlerThread,方便我们使用Looper。

 public class HandlerThread extends Thread {
 
     Looper mLooper;
 
     /**
      * Call back method that can be explicitly overridden if needed to execute some
      * setup before Looper loops.
      */
     protected void onLooperPrepared() {
     }
 
     public void run() {
         mTid = Process.myTid();
         Looper.prepare();
         synchronized (this) {
             mLooper = Looper.myLooper();
             notifyAll();
         }
         Process.setThreadPriority(mPriority);
         onLooperPrepared();
         Looper.loop();
         mTid = -1;
     }
 
     /**
      * This method returns the Looper associated with this thread. If this thread not been started
      * or for any reason is isAlive() returns false, this method will return null. If this thread
      * has been started, this method will block until the looper has been initialized.
      * @return The looper.
      */
     public Looper getLooper() {
         if (!isAlive()) {
             return null;
         }
 
         // If the thread has been started, wait until the looper has been created.
         synchronized (this) {
             while (isAlive() && mLooper == null) {
                 try {
                     wait();
                 } catch (InterruptedException e) {
                 }
             }
         }
         return mLooper;
     }
 
 }