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;
    }
    
 
}