public class HandlerTest extends Activity {
	/** Called when the activity is first created. */
	private Button startButton;
	private Button endButton;
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		// 根据id获得控件对象
		startButton = (Button) findViewById(R.id.startButton);
		endButton = (Button) findViewById(R.id.endButton);
		// 为控件设置监听器
		startButton.setOnClickListener(new StartButtonListener());
		endButton.setOnClickListener(new EndButtonListener());
	}
	class StartButtonListener implements OnClickListener {
		public void onClick(View v) {
			// 调用Handler的post()方法，将要执行的线程对象放到队列当中
			handler.post(updateThread);
		}
	}
	class EndButtonListener implements OnClickListener {
		public void onClick(View v) {
			// 调用Handler的removeCallbacks()方法，删除队列当中未执行的线程对象
			handler.removeCallbacks(updateThread);
		}
	}
	// 创建Handler对象
	Handler handler = new Handler();
	// 新建一个线程对象
	Runnable updateThread = new Runnable() {
		// 将要执行的操作写在线程对象的run方法当中
		public void run() {
			System.out.println("updateThread");
			// 调用Handler的postDelayed()方法
			// 这个方法的作用是：将要执行的线程对象放入到队列当中，待时间结束后，运行制定的线程对象
			// 第一个参数是Runnable类型：将要执行的线程对象
			// 第二个参数是long类型：延迟的时间，以毫秒为单位
			handler.postDelayed(updateThread, 3000);
		}
	};
}

示例2：

一个应用程序中有一个进度条和一个按钮，当点击按钮后，每隔一秒钟进度条前进一部分。

下图为应用程序的运行效果图：

public class ProgressBarHandlerTest extends Activity {
	/** Called when the activity is first created. */
	private ProgressBar progressBar;
	private Button startButton;
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		progressBar = (ProgressBar) findViewById(R.id.progressbar);
		startButton = (Button) findViewById(R.id.startButton);
		startButton.setOnClickListener(new ProgressBarOnClickListener());
	}
	class ProgressBarOnClickListener implements OnClickListener {
		public void onClick(View v) {
			// 设置进度条为可见状态
			progressBar.setVisibility(View.VISIBLE);
			updateBarHandler.post(updateThread);
		}
	}
	// 使用匿名内部类来复写Handler当中的handlerMessage()方法
	Handler updateBarHandler = new Handler() {
		@Override
		public void handleMessage(Message msg) {
			progressBar.setProgress(msg.arg1);
			updateBarHandler.post(updateThread); // 将要执行的线程放入到队列当中
		}
	};
	// 线程类，该类使用匿名内部类的方式进行声明
	Runnable updateThread = new Runnable() {
		int i = 0;
		public void run() {
			// TODO Auto-generated method stub
			System.out.println("Begin Thread");
			i += 10;
			// 得到一个消息对象，Message类是android系统提供的
			Message msg = updateBarHandler.obtainMessage();
			// 将Message对象的arg1参数的值设置为i
			msg.arg1 = i; // 用arg1、arg2这两个成员变量传递消息，优点是系统性能消耗较少
			try {
				Thread.sleep(1000); // 让当前线程休眠1000毫秒
			} catch (InterruptedException ex) {
				ex.printStackTrace();
			}
			// 将Message对象加入到消息队列当中
			updateBarHandler.sendMessage(msg);
			// 如果i的值等于100
			if (i == 100) {
				// 将线程对象从队列中移除
				updateBarHandler.removeCallbacks(updateThread);
			}
		}
	};
}

Handler与线程的关系

Handler在默认情况下，实际上它和调用它的Activity是处于同一个线程的。

例如在Handler的使用（一）的示例1中，虽然声明了线程对象，但是在实际调用当中它并没有调用线程的start()方法，而是直接调用当前线程的run()方法。

通过一个例子来证实一下

一个Android应用程序，在Activity中创建Handler和线程对象，并且在Activity的onCreate()方法中输出当前线程的id和名字，然后在线程对象的run方法中也打印输出下当前线程的id和名字。如果说，Activity输出的结果与线程对象输出的结果是一样的，那么就表示它们使用的是同一个线程。

下面是Activity代码：

public class HandlerTwo extends Activity {
	/** Called when the activity is first created. */
	Handler handler = new Handler();
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		// 在设置布局文件之前先调用post方法，
		// 表示在执行完线程之后才会显示布局文件中的内容，而线程中又设置了休眠10秒钟，
		// 所以最终效果为，先显示应用程序主界面，等待10秒钟之后才显示布局文件中的内容
		handler.post(r);
		setContentView(R.layout.main);
		System.out.println("activity id--->" + Thread.currentThread().getId());
		System.out.println("activity name--->
				+ Thread.currentThread().getName());
	}
	Runnable r = new Runnable() {
		public void run() {
			// 输出当前线程的id和name
			// 如果这里输出的线程id、name与上面onCreate()方法中输出的线程id、name相同的话，
			// 那么则表示，他们使用的是同一个线程
			System.out.println("runnable_id--->
					+ Thread.currentThread().getId());
			System.out.println("runnable_name--->
					+ Thread.currentThread().getName());
			try {
				Thread.sleep(10000); // 让线程休眠10秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	};
}

根据结果可以看出，两个输出的id和name都相同，它们使用的是同一个线程。

现在将Activity中的代码修改一下，新建一个线程Thread，然后调用线程的start()方法，再观察一下控制台的输出结果。

这里只要将上面的代码稍微修改一下就可以了。

1、先将handler.post(r)注释掉。

2、再添加下面两句代码就OK了。

//handler.post(r); 
Thread t = new Thread(r); 
t.start();

从这个输出结果中可以看出，这次线程对象的id、name与activity里的线程id、name完全不一样了，由此可见，它们现在使用的不是同一个线程。

这个例子中还掩饰了一个效果，就是平时我们是将Handler的post()方法放在setContentView(R.layout.main)这个方法之后调用，将设置完布局之后再执行其他的操作，而在这个例子中，是将Handler的post()方法放在setContent()方法之前调用，而post里传递的线程对象的run()方法呢，又执行了休眠线程10秒钟，所以运行实现的效果会是，当程序运行后，首先Activity上没有任何内容，过来10秒之后，才会显示Activity里的内容。

欢迎阅读下篇：