在这里为大家介绍ProgressDialog的使用方法：

1) 创建一个普通ProgressDialog（不带有ProgressBar）所必须的几个参数

• Context: 指定当前Dialog的Container
• Title:对话框标题
• Message:对话框主体所显示的信息
• Indeterminate:不确定性属性，这个属性对于ProgressDailog默认的转轮模式没有实际意义，默认下设置为true，它仅仅对带有ProgressBar的Dialog有作用。

2）以下两个为可选参数

• Cancelable:增加一个可以Cancel当前Dialog的按钮，强制退出。
• CancelListner:当前Dialog强制取消之后将会被执行，通常用来清理未完成的任务。

快速创建一个ProgressDialog的方法（代码片段）：

    private ProgressDialog dialog;
    private Handler handler = new Handler() {
        public void handleMessage(Message msg)
        {
        	dialog.dismiss();
        }
    };
    private Thread checkUpdate = new Thread()
    {
    	public void run() {  

    	  try {
			sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	  handler.sendEmptyMessage(0);
    	}
    };
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);    

	    final Button button = (Button) findViewById(R.id.Compute);
	    button.setOnClickListener(new View.OnClickListener()
	    {

			public void onClick(View arg0) {
				// TODO Auto-generated method stub
				checkUpdate.stop();
				dialog = ProgressDialog.show(ARTestDrawing2D.this,
					      "AndroidRes",
						  "I am thinking...",
						  true,true);
				checkUpdate.start();
			}

	    });
    }

上边的例子中引用了Handler（official）作为multi-thread相互传递数据的载体，接下来为ProgressDialog实现一个可视化进度条(progressBar)的方法中依然需要调用Handler(Internal)，借用这个例子大家也可以多了解Handler的用法。

利用一个可视化进度条取代第一个例子中比较抽象的旋转轮，让用户更加直观的了解当前任务的进度。初始化的方法如下：

dialog = new ProgressDialog(ARTestDrawing2D.this);
dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
dialog.setTitle("AndroidRes");
dialog.setMessage("I am thinking...");

看起来稍微比第一个例子复杂一些，每个参数都单独利用成员方法赋值。
其中SetProgressStyle用来设置显示模式，通常为STYLE_HORIZONTAL。下边通过一个完整的例子了解它的初始化和设置方法（例子来源于Android官网）：

    static final int PROGRESS_DIALOG = 0;
    Button button;
    ProgressThread checkUpdate;
    ProgressDialog dialog;

    /** Called when the activity is first created. */
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Setup the button that starts the progress dialog
        button = (Button) findViewById(R.id.Compute);
        button.setOnClickListener(new OnClickListener(){
            public void onClick(View v) {
                showDialog(PROGRESS_DIALOG);
            }
        });
    }

    protected Dialog onCreateDialog(int id) {
        switch(id) {
        case PROGRESS_DIALOG:
        	dialog = new ProgressDialog(ARTestDrawing2D.this);
        	dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        	dialog.setTitle("AndroidRes");
        	dialog.setMessage("I am thinking...");
        	checkUpdate = new ProgressThread(handler);
        	checkUpdate.start();
            return dialog;
        default:
            return null;
        }
    }

    // Define the Handler that receives messages from the thread and update the progress
    final Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            int total = msg.getData().getInt("total");
            dialog.setProgress(total);
            if (total >= 100){
                dismissDialog(PROGRESS_DIALOG);
                checkUpdate.setState(ProgressThread.STATE_DONE);
                total = 0;
            }
        }
    };

    /** Nested class that performs progress calculations (counting) */
    private class ProgressThread extends Thread {
        Handler mHandler;
        final static int STATE_DONE = 0;
        final static int STATE_RUNNING = 1;
        int mState;
        int total;

        ProgressThread(Handler h) {
            mHandler = h;
        }

        public void run() {
            mState = STATE_RUNNING;
            total = 0;
            while (mState == STATE_RUNNING) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Log.e("ERROR", "AndroidRes Thread Interrupted");
                }
                Message msg = mHandler.obtainMessage();
                Bundle b = new Bundle();
                b.putInt("total", total);
                msg.setData(b);
                mHandler.sendMessage(msg);
                total++;
            }
        }

        /* sets the current state for the thread,
         * used to stop the thread */
        public void setState(int state) {
            mState = state;
        }
    }

例子理解起来相对比较容易，对两个比较主要的对象做个简单的说明：
checkUpdate: 从主线程中创建一个用于计算某项任务的线程，同时也是利用ProgessBar所追踪的对象，指示这个线程的任务进度。
handler: 利用这个Handler可以将线程中的数据实时反映到主线程中的ProgessBar，使其可以实时接收到最新进度数据。

对于没有过类似需求的开发者来讲，在这个过程中需要更加细心的了解每个步骤所代表的含义，而且必要时可以在文章后边提出困惑的问题。

这个例子的代码相比以前稍微多了一些，有必要强调阅读代码的技巧。分析别人写的代码是一件非常艰巨的任务，尤其是面对庞大的类群或者在缺少注释的环境下。有经验的程序员在摸爬滚打中都培养出各自习惯的方式来处理各种棘手的问题。无论有哪些方法，其所具备的共同点是要细心的对待每一行代码，具备耐心和目的性，要了解当前所分析的代码实现的功能。不在这里更深入的讨论这个话题，向有感兴趣的朋友推荐一本讲述如何阅读代码的参考资料《Code Reading》，这个作者另外一本值得阅读的书是《Code Quality》，都值得阅读。

这次要分析的代码来自AndroidSnippets.org，对于经常光顾AR的朋友应该非常了解，本站对于他们的内容时刻保持着关注，除了粘贴一些例子以外，更主要的是剖析例子中所涉及的知识点，这是体现AndroidRes存在价值的方式。上边的一些话扯的稍远了点，让我们回到正题吧。

介绍本例中两个最基本的类：其中第一个是承载HandlerThread和Handler的类，另外一个是用来装载实例的容器，二者的关系可以看作为玻璃球和玻璃球罐子。

先来分析第一个类，“玻璃球”的内部除了包括HandlerThread和Handler以外，还需要创建一个默认的消息响应类，为了体现很好的拓展性，可以在声明“玻璃球”类时指定其它HandleMessage方法。下边先来看完整的源代码（保留原有英文注释）：

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.os.Handler.Callback;
import android.util.Log;  

/**
 * The transceiver provides a convenient way to decorate an instance with receive and transmit capabilities.
 * It can (and this is encouraged) be used with the {@link Broker} instance.
 * The naming thing is not part of the Transeiver's functionality, but may be useful while debugging.
 * This class can be used for subclassing or as a "has-a"-relation, as it is possible to set
 * an arbitrary {@link Callback } listener.
 *
 */
public class Transceiver {
    private String mName="Transceiver";
    private static int ID=0;  

    private HandlerThread mHandlerThread;
    private Handler mHandler;  

    // delegates the messages, when no proprietary callback
    // is associated with the transeiver
    private class HandlerListener implements Callback{   

        @Override
        public boolean handleMessage(Message msg) {
            return Transceiver.this.handleMessage(msg);
        }  

    }  

    /**
     * Creates a transceiver with an automatically generated name
     */
    public Transceiver(){
        mName = new String("Transceiver(" + ++ID + ")");
        create(new HandlerListener());
    }  

    /**
     * Creates a transceiver with arbitrary name
     * @param name
     */
    public Transceiver(String name){
        ++ID;
        mName = name;
        create(new HandlerListener() );
    }  

    /**
     * Creates a transceiver with arbitrary name and an own listener
     * @param name a custom name
     * @param l your own listener
     */
    public Transceiver(String name, Callback l){
        ++ID;
        mName = name;
        create(l);
    }  

    private void create(Callback l){
        mHandlerThread = new HandlerThread(getName());
        mHandlerThread.start();
        Log.d(mName, "Waiting for looper...");
        // we need to wait (blocking) to get the looper instance
        while(!mHandlerThread.isAlive()) {};
        mHandler = new Handler(mHandlerThread.getLooper(), l);
        Log.d(mName, "Ready");
    }  

    /**
     * @return The name of this transceiver
     */
    public final String getName() { return mName; }  

    /**
     * @return Its internal handler
     */
    public final Handler getHandler() { return mHandler; }  

    /**
     * The callback method for received messages. You can override it, when deriving from Transceiver.
     * @param msg the message
     * @return true, if the message was handled.
     */
    public boolean handleMessage(Message msg) { return false; }
}

按照物理顺序详细分析代码的作用：

• mName和ID用来给线程添加一个可识别的标签；
• mHandlerThread和mHandler两个变量分别装载当前线程中HandlerThread和Handler的实例；
• HandlerListener类作为Callback的子类，响应Message信息的行为定义在  HandleMessage 方法中。在这个例子中实际的行为写在类中的一个独立方法中，然后再由HandleMessage去调用这个方法，这样做的目的为了让其子类可以重写基类（Transceiver)中HandleMessage的行为。
• 三种不同的构造函数。第一个可以根据系统自动分配线程标签，第二个是接受指定命名，前两种还有一个共同点是使用类中默认的handleMessage，第三个包含两个参数，一个是标签名称，另外一个用于自定义新的handlerMessage行为。
• create方法是创建HandlerThread的核心部分，将Callback类型参数应用于HandlerThread的Looper类中处理消息循环（接收信息并作出回应 – Looper class used to run a message loop for a thread.）。
• getName和getHandler无需解释，一个是用于返回当前HandlerThread标签的方法，另外一个返回Handler实例。

接下来分析“玻璃球盒子”。小时候经常将手中的玻璃球随意乱放，而且经常有丢失的情况发生，就是因为没有一个统一管理的方法。当创建了多个HandlerThread之后，有必要设置一个容器将它们合理的安置，以至于当需要的时候可以快速的通过标签找到想要索引的线程。下边先来看完整的源代码（保留原有英文注释）：

import java.util.ArrayList;
import android.os.Handler;
import android.os.Message;  

/**
 * The broker is a kind of repository for {@link Handler} instances. It provides a simple and very convenient mechanism to
 * establish communication between different handlers. Just subscribe a handler instance and use the returned address with
 * this Broker. This class is thread safe, of course.
 * Usage example:
 * 
 * this.MyCompAddr = Broker.instance.subscribe( new Handler() );
 * // or, when using transceiver
 * this.MyRendererAddr = Broker.instance.subscribe( new MyTransceiver("Renderer").getHandler() );
 * [...]
 * // how to send messages
 * Message m = Message.obtain();
 * m.what = 1; // could be an identifier or op-code or whatever you want
 * Bundle b= new Bundle(); // or use more complex (key,value)-pairs.
 * b.putString("data", "Any Data");
 * m.setData(b);
 * Broker.instance.post(this.MyRendererAddr, m);
 * 
 *
 */
public class Broker {  

    /**
     * The static instance.
     */
    public static Broker instance=new Broker();
    private ArrayList< Handler > mHandler;  

    private Broker()
    {
        mHandler = new ArrayList< Handler > ();
    }  

    /**
     * Subscribe a handler, so you can send messages easily to it.
     * Mind there is no check for doubled subscription.
     * @param h The handler
     * @return The "address" for the handler
     * @see {@link unsubscribe() }
     */
    public synchronized int subscribe(Handler h){
        ArrayList< Handler > hl=mHandler;
        hl.add(h);
        return hl.size()-1;
    }  

    /**
     * Unsubscribes a handler. Invalid addresses are ignored
     * @param address
     */
    public synchronized void unsubscribe(int address){
        if(isAddressValid(address))
            mHandler.remove(address);
    }  

    protected synchronized final boolean isAddressValid(int address){
        ArrayList< Handler > h=mHandler;
        return (!h.isEmpty() && address >= 0 && address < h.size() );
    }  

    /**
     * Post a message to addressed receiver.
     * @param address
     * @param m
     * @return true, if address exists, i.e. message could be delivered
     */
    public synchronized boolean post(int address, Message m){
        ArrayList< Handler > h=mHandler;
        if(!isAddressValid(address))
            return false;  

        h.get(address).sendMessage(Message.obtain(m));
        return true;  

    }  

    /**
     * Sends a message to all connected handler
     * @param m The message
     * @return The number of notified handler, e.g. send messages.
     */
    public synchronized int broadcast(Message m)    {
        ArrayList< Handler > h=mHandler;
        int n=h.size();
        for(int i=0; i < n; ++i)
        {
            h.get(i).sendMessage(Message.obtain(m));
        }
        return n;
    }
}

按照物理顺序详细分析代码的作用：

• instance：在Broker类中创建一个静态实例，可以在其它方法中直接调用其资源。
• mHandler：这个是用来存放Handler实例的数组，也是这个容器的核心，后边所创建的方法都针对这个数组来操作。
• Broker(): 类内部的构造函数。它为mHandler建立一个ArrayList<Handler>数组实例。
• subscribe()：相当于数组的"Add"方法，返回值是当前所添加的Handler在mHandler数组中的“座位号”。
• unsubscribe(): 相当于数组的"Remove"方法，传递一个“座位号”可以将它的实例从mHandler中移除。
• isAddressValid(): 验证“座位号”的合法性，其原理仅仅是判断这个号是否超出了当前数组中子集的数量或者是否为不小于0的整数。
• post(): 根据“座位号”将Message发送给这个指定的线程。
• broadcast(): 可以根据这个意思理解为拿个大喇叭对当前容器内的所有线程实例广播。如果说post是k98步枪，那么这个可以算得上是MG42了。

以上就是对线程间通讯方法的简单介绍，下边是一些更加实际的例子，可以帮助大家理解如何在你的程序中调用上边的类。

例子一：

/**
* a place where I store my addresses.
* Read-only access to once set addresses is thread-safe!
*/
public class AddressPool {
    public static int Subsystem1,Subsystem2,MyActivity;
}  

// #extending Transceiver (is-a-relation) # 

public class Subsystem2 extends Transceiver {
    public final static String TAG="Subsystem2";
    public final static int WHAT = 3862; // a magic number  

    public boolean handleMessage(Message m){  

        switch(m.what){
        case Subsystem1.WHAT:
            Log.i(TAG,"Received message from " + Subsystem1.TAG);
            // attention: when answering we need a new message
            Message msg= Message.obtain(m);
            Broker.instance.post(AddressPool.Subsystem1, msg);
            break;
        case MyActivity.WHAT:
            Log.i(TAG,"Received message from " + MyActivity.TAG );
            break;
        }
        return true;
    }
}

例子二：

// #wrapping/using Transceiver (has-a-relation) # 

package com.o1.android;  

import java.util.Timer;
import java.util.TimerTask;  

import com.o1.android.util.message.Broker;
import com.o1.android.util.message.Transceiver;  

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;
import android.os.Handler.Callback;
import android.util.Log;  

public class Subsystem1 extends TimerTask implements Callback{
    public final static String TAG="Subsystem1";
    public final static int WHAT = 175; // any identifier
    private Transceiver mTransceiver;
    private int mMyAddress=-1;
    private Timer mTimer;  

    public Subsystem1(){
        mTransceiver = new Transceiver(TAG, this);
        mTimer = new Timer("SubsystemTimer");  

    }  

    public void onStart(){
        mMyAddress = Broker.instance.subscribe(mTransceiver.getHandler());
        // we use a timer to asynchronously post messages
        mTimer.schedule(this, 0, 125);
    }  

    public void onQuit(){
        mTimer.cancel();
        Broker.instance.unsubscribe(mMyAddress);
    }  

    public final int getBrokerAddress() { return mMyAddress; }  

    @Override
    public boolean handleMessage(Message m) {
        switch(m.what){
        case Subsystem2.WHAT:
            Log.i(TAG,"Received message from " + Subsystem2.TAG);
            break;
        case MyActivity.WHAT:
            Log.i(TAG,"Received message from " + MyActivity.TAG);
            break;
        }
        // immediate response/delegate with a copy of our message
        Broker.instance.post(AddressPool.MyActivity, Message.obtain(m));
        return true;
    }  

    @Override
    public void run() {
        Message m= new Message();
        m.what=WHAT;
        Broker.instance.post(AddressPool.MyActivity, m);
    }
}

例子三：

// #connecting activities # 

public class MyActivity extends Activity implements Callback {  

     private Subsystem1 mSubsystem1;
     //... other member fields  

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        /*
        * We have different types of transceiver implementations.
        * One as "has" (subsystem1) and the other as "is"-relation.
        */
        mSubsystem1 = new Subsystem1();
        AddressPool.Subsystem2 = Broker.instance.subscribe(new Subsystem2().getHandler());
        // additionally, we can use activities (or other components with loopers)
        // mind that our activity implements Callback
        AddressPool.MyActivity = Broker.instance.subscribe(new Handler(this));
        // ... your stuff, e.g. a button that triggers messages  

    }   

    @Override
    public void onStart(){
        super.onStart();
        mSubsystem1.onStart();
        AddressPool.Subsystem1 = mSubsystem1.getBrokerAddress();
    }  

    @Override
    public void onDestroy(){
        super.onDestroy();
        mSubsystem1.onQuit();
    }  

    @Override
    public boolean handleMessage(Message msg) {
       // handle your messages here
    }

查看原文 AndroidSnippets.org

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.TextView;

public class Main extends Activity  {
   private TextView txtStatus;
   private RefreshHandler mRedrawHandler = new RefreshHandler();

   class RefreshHandler extends Handler {
      @Override
      public void handleMessage(Message msg) {
         Main.this.updateUI();
      }

      public void sleep(long delayMillis) {
         this.removeMessages(0);
         sendMessageDelayed(obtainMessage(0), delayMillis);
      }
   };

   private void updateUI(){
      int currentInt = Integer.parseInt((String) txtStatus.getText()) + 10;
      if(currentInt <= 100){
         mRedrawHandler.sleep(1000);
         txtStatus.setText(String.valueOf(currentInt));
      }
   }

   @Override
   public void onCreate(Bundle icicle) {
      super.onCreate(icicle);
      setContentView(R.layout.main);
      this.txtStatus = (TextView) this.findViewById(R.id.txtStatus);
      updateUI();
   }
}

简短说明(Quick explanation):
创建一个继承Handler的Class，一定要重新实现(Override)类中的handleMessage方法 （ Subclasses must implement this to receive messages. ）。然后再声明Sleep方法，其目的是调用延迟发送Message的方法 sendMessageDelayed。updateUI作为核心方法，修改TextView中的数值。其本身包含有调用Sleep的方法和一个终止Handler的判断条件。
建议在看源代码时，实际创建一个工程来测试这段简单的代码，可以更容易了解Handler的执行过程。

Layout 源码：

官方文档：Handler

Via Almond mendoza