Android Handler的使用二

2、sendMessage版本的Handler的使用

a、默认的Handler（消息处理队列挂在主线程上）

package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity
implements OnClickListener {
private final static String TAG = "HandlerTest";

private final static int TASK_BEGIN	= 1;
private final static int TASK_1	= 2;
private final static int TASK_2	= 3;
private final static int TASK_END	= 4;

private Button btnStart = null;
private Button btnStop = null;

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

btnStart = (Button) findViewById(R.id.btn_start);
btnStart.setOnClickListener(this);
btnStop = (Button) findViewById(R.id.btn_stop);
btnStop.setOnClickListener(this);

Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]");
}

Handler mHandler = new Handler() {
// 注意：在各个case后面不能做太耗时的操作，否则出现ANR对话框
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case TASK_BEGIN:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_BEGIN");
break;

case TASK_1:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_1");
break;

case TASK_2:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_2");
break;

case TASK_END:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_END");
finish();
break;
}
super.handleMessage(msg);
}
};

public void onClick(View view) {
switch (view.getId()) {
case R.id.btn_start:
// 启动任务（消息只有标识，立即投递）
mHandler.sendEmptyMessage(TASK_BEGIN);
Log.i(TAG, "Send TASK_BEGIN to handler.");

// 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）
Message msg1 = mHandler.obtainMessage(TASK_1);
msg1.obj = "This is task1";
mHandler.sendMessage(msg1);
Log.i(TAG, "Send TASK_1 to handler.");

// 开启任务2（和上面类似）
Message msg2 = Message.obtain();
msg2.arg1 = 10;
msg2.arg2 = 20;
msg2.what = TASK_2;
mHandler.sendMessage(msg2);
Log.i(TAG, "Send TASK_2 to handler.");
break;

case R.id.btn_stop:
// 结束任务（空消息体，延时2s投递）
mHandler.sendEmptyMessageDelayed(TASK_END, 2000);
Log.i(TAG, "Send TASK_END to handler.");
break;
}
}
}

运行结果：



b、消息队列仍绑定在主线程上，但在子线程中发送消息。

package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
private final static String TAG = "HandlerTest";

private final static int TASK_BEGIN	= 1;
private final static int TASK_1	= 2;
private final static int TASK_2	= 3;
private final static int TASK_END	= 4;

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

Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
"This is in main thread.");

workThread.start();
}

Handler mHandler = new Handler() {
// 注意：在各个case后面不能做太耗时的操作，否则出现ANR对话框
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case TASK_BEGIN:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_BEGIN");
break;

case TASK_1:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_1");
break;

case TASK_2:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_2");
break;

case TASK_END:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_END");
finish();
break;
}
super.handleMessage(msg);
}
};

Thread workThread = new Thread() {
// 你可以在run方法内做任何耗时的操作，然后将结果以消息形式投递到主线程的消息队列中
@Override
public void run() {
// 启动任务（消息只有标识，立即投递）
mHandler.sendEmptyMessage(TASK_BEGIN);
Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
"Send TASK_START to handler.");

// 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）
Message msg1 = mHandler.obtainMessage(TASK_1);
msg1.obj = "This is task1";
mHandler.sendMessage(msg1);
Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
"Send TASK_1
4000
to handler.");

// 开启任务2（和上面类似）
Message msg2 = Message.obtain();
msg2.arg1 = 10;
msg2.arg2 = 20;
msg2.what = TASK_2;
mHandler.sendMessage(msg2);
Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
"Send TASK_2 to handler.");

// 结束任务（空消息体，延时2s投递）
mHandler.sendEmptyMessageDelayed(TASK_END, 2000);
Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
"Send TASK_END to handler.");
}
};
}

运行结果：



c、将消息队列绑定到子线程上，主线程只管通过Handler往子线程的消息队列中投递消息即可。

package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
private final static String TAG = "HandlerTest";

private final static int TASK_BEGIN	= 1;
private final static int TASK_1	= 2;
private final static int TASK_2	= 3;
private final static int TASK_END	= 4;

private MyHandler mHandler = null;

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

Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
"This is in main thread.");

HandlerThread myLooperThread = new HandlerThread("my looper thread");
myLooperThread.start();

Looper looper = myLooperThread.getLooper();
mHandler = new MyHandler(looper);

// 启动任务（消息只有标识，立即投递）
mHandler.sendEmptyMessage(TASK_BEGIN);
Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_START to handler.");

// 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）
Message msg1 = mHandler.obtainMessage(TASK_1);
msg1.obj = "This is task1";
mHandler.sendMessage(msg1);
Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_1 to handler.");

// 开启任务2（和上面类似）
Message msg2 = Message.obtain();
msg2.arg1 = 10;
msg2.arg2 = 20;
msg2.what = TASK_2;
mHandler.sendMessage(msg2);
Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_2 to handler.");

// 结束任务（空消息体，延时2s投递）
mHandler.sendEmptyMessageDelayed(TASK_END, 2000);
Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_END to handler.");
}

class MyHandler extends Handler {
public MyHandler(Looper looper) {
super(looper);
}

// 现在在每个case之后，你可以做任何耗时的操作了
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case TASK_BEGIN:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_BEGIN");
break;

case TASK_1:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_1");
break;

case TASK_2:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_2");
break;

case TASK_END:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_END");
finish();
break;
}
super.handleMessage(msg);
}
}
}

运行结果：



d、自己创建新的线程，然后在新线程中创建Looper，主线程调用子线程中的发消息方法，将消息发给子线程的消息队列。

package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
private final static String TAG = "HandlerTest";

private final static int TASK_BEGIN = 1;
private final static int TASK_1 = 2;
private final static int TASK_2 = 3;
private final static int TASK_END = 4;

private Handler workHandler = null;

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

Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
"This is in main thread.");

LooperThread testThread = new LooperThread();
testThread.start();

// 注意，这里需要等待一下，防止出现空指针异常
while (null == workHandler) {
}

testThread.sendMessageTodoYourWork();
}

class LooperThread extends Thread {
@Override
public void run() {
Looper.prepare();

workHandler = new Handler() {
// 现在在每个case之后，你可以做任何耗时的操作了
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case TASK_BEGIN:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_BEGIN");
break;

case TASK_1:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_1");
break;

case TASK_2:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_2");
break;

case TASK_END:
Log.i(TAG, "[H_TID:" +
Thread.currentThread().getId() + "] Get TASK_END");
Looper.myLooper().quit();
finish();
break;
}
super.handleMessage(msg);
}
};

Looper.loop();
}

public void sendMessageTodoYourWork() {
Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_START to handler.");
// 启动任务（消息只有标识，立即投递）
workHandler.sendEmptyMessage(TASK_BEGIN);

Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_1 to handler.");
// 开始任务1（在workHandler的消息队列中获取一个Message对象，避免重复构造）
Message msg1 = workHandler.obtainMessage(TASK_1);
msg1.obj = "This is task1";
workHandler.sendMessage(msg1);

Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_2 to handler.");
// 开启任务2（和上面类似）
Message msg2 = Message.obtain();
msg2.arg1 = 10;
msg2.arg2 = 20;
msg2.what = TASK_2;
workHandler.sendMessage(msg2);

Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_END to handler.");
// 结束任务（空消息体，延时2s投递）
workHandler.sendEmptyMessageDelayed(TASK_END, 2000);
}
}
}

运行结果：



e、主/子线程均有一个消息队列，然后相互传递消息（这种方式是最灵活的，双向传递，也不复杂）

package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
private final static String TAG = "HandlerTest";

private final static int TASK_BEGIN = 1;
private final static int TASK_1 = 2;
private final static int TASK_2 = 3;
private final static int TASK_END = 4;

private final static int TASK_BEGIN_OVER = 11;
private final static int TASK_1_OVER = 12;
private final static int TASK_2_OVER = 13;
private final static int TASK_END_OVER = 14;

private Handler workHandler = null;

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

Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
"This is in main thread.");

LooperThread testThread = new LooperThread();
testThread.start();

// 注意，这里需要等待一下，防止出现空指针异常
while (null == workHandler) {
}

testThread.sendMessageTodoYourWork();
}

Handler mainHandler = new Handler () {
// 在每个case之后，不能做耗时的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case TASK_BEGIN_OVER:
Log.i(TAG, "[MH_TID:" +
Thread.currentThread().getId() + "] TASK_BEGIN_OVER");
break;

case TASK_1_OVER:
Log.i(TAG, "[MH_TID:" +
Thread.currentThread().getId() + "] TASK_1_OVER");
break;

case TASK_2_OVER:
Log.i(TAG, "[MH_TID:" +
Thread.currentThread().getId() + "] TASK_2_OVER");
break;

case TASK_END_OVER:
Log.i(TAG, "[MH_TID:" +
Thread.currentThread().getId() + "] TASK_END_OVER");
finish();
break;
}
super.handleMessage(msg);
}
};

class LooperThread extends Thread {
@Override
public void run() {
Looper.prepare();

workHandler = new Handler() {
// 现在在每个case之后，你可以做任何耗时的操作了
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case TASK_BEGIN:
Log.i(TAG, "[ZH_TID:" +
Thread.currentThread().getId() + "] Get TASK_BEGIN");
// 做完之后报告信息给主线程
mainHandler.sendEmptyMessage(TASK_BEGIN_OVER);
break;

case TASK_1:
Log.i(TAG, "[ZH_TID:" +
Thread.currentThread().getId() + "] Get TASK_1");
// 做完之后报告信息给主线程
mainHandler.sendEmptyMessage(TASK_1_OVER);
break;

case TASK_2:
Log.i(TAG, "[ZH_TID:" +
Thread.currentThread().getId() + "] Get TASK_2");
// 做完之后报告信息给主线程
mainHandler.sendEmptyMessage(TASK_2_OVER);
break;

case TASK_END:
Log.i(TAG, "[ZH_TID:" +
Thread.currentThread().getId() + "] Get TASK_END");
Looper.myLooper().quit();
// 做完之后报告信息给主线程
mainHandler.sendEmptyMessage(TASK_END_OVER);
Looper.myLooper().quit();
break;
}
super.handleMessage(msg);
}
};

Looper.loop();
}

public void sendMessageTodoYourWork() {
Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_START to handler.");
// 启动任务（消息只有标识，立即投递）
workHandler.sendEmptyMessage(TASK_BEGIN);

Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_1 to handler.");
// 开始任务1（在workHandler的消息队列中获取一个Message对象，避免重复构造）
Message msg1 = workHandler.obtainMessage(TASK_1);
msg1.obj = "This is task1";
workHandler.sendMessage(msg1);

Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_2 to handler.");
// 开启任务2（和上面类似）
Message msg2 = Message.obtain();
msg2.arg1 = 10;
msg2.arg2 = 20;
msg2.what = TASK_2;
workHandler.sendMessage(msg2);

Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
"Send TASK_END to handler.");
// 结束任务（空消息体，延时2s投递）
workHandler.sendEmptyMessageDelayed(TASK_END, 2000);
}
}
}

运行结果：



 小结：Handler在Android中是很常用的，或是用来更新UI，或是派发任务给子线程去执行，也可以用来产生超时效果，比如用sendMessageDelayed(TASK_TIMEOUT,
OUT_TIME)方法。