Android单线程模型
16lz
2021-01-23
单线程模型
当一个程序第一次启动时,Android会同时启动一个对应的主线程(Main Thread),主线程主要负责处理与UI相关的事件,如用户的按键事件,用户接触屏幕的事件以及屏幕绘图事件,并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线程。在开发Android应用时必须遵守单线程模型的原则: Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。
2.1 子线程更新UI
Android的UI是单线程(Single-threaded)的。为了避免拖住GUI,一些较费时的对象应该交给独立的线程去执行。如果幕后的线程来执行UI对象,Android就会发出错误讯息
CalledFromWrongThreadException。以后遇到这样的异常抛出时就要知道怎么回事了!
2.2 Message Queue
在单线程模型下,为了解决类似的问题,Android设计了一个Message Queue(消息队列), 线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。下面将对它们进行分别介绍:
1. Message
Message消息,理解为线程间交流的信息,处理数据后台线程需要更新UI,则发送Message内含一些数据给UI线程。
2. Handler
Handler处理者,是Message的主要处理者,负责Message的发送,Message内容的执行处理。后台线程就是通过传进来的Handler对象引用来sendMessage(Message)。而使用Handler,需要implement 该类的 handleMessage(Message)
方法,它是处理这些Message的操作内容,例如Update UI。通常需要子类化Handler来实现handleMessage方法。
3. Message Queue
Message Queue消息队列,用来存放通过Handler发布的消息,按照先进先出执行。
每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息:sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同:通过sendMessage发送的是一个message对象,会被Handler的handleMessage()函数处理;而通过post方法发送的是一个runnable对象,则会自己执行。
4. Looper
Looper是每条线程里的Message Queue的管家。Android没有Global的Message Queue,而Android会自动替主线程(UI线程)建立Message Queue,但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL,但调用Looper.myLooper()得到当前线程的Looper就有可能为NULL。
对于子线程使用Looper,API Doc提供了正确的使用方法:
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare(); //创建本线程的Looper并创建一个MessageQueue
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop(); //开始运行Looper,监听Message Queue
}
}
这个Message机制的大概流程:
1. 在Looper.loop()方法运行开始后,循环地按照接收顺序取出Message Queue里面的非NULL的Message。
2. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)到Message Queue,该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message,则调用该Message的target指向的Hander的dispatchMessage函数对Message进行处理。
在dispatchMessage方法里,如何处理Message则由用户指定,三个判断,优先级从高到低:
1) Message里面的Callback,一个实现了Runnable接口的对象,其中run函数做处理工作;
2) Handler里面的mCallback指向的一个实现了Callback接口的对象,由其handleMessage进行处理;
3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数,通过这个实现的handleMessage函数处理消息。
由此可见,我们实现的handleMessage方法是优先级最低的!
3. Handler处理完该Message (update UI) 后,Looper则设置该Message为NULL,以便回收!
在网上有很多文章讲述主线程和其他子线程如何交互,传送信息,最终谁来执行处理信息之类的,个人理解是最简单的方法——判断Handler对象里面的Looper对象是属于哪条线程的,则由该线程来执行!
1. 当Handler对象的构造函数的参数为空,则为当前所在线程的Looper;
2. Looper.getMainLooper()得到的是主线程的Looper对象,Looper.myLooper()得到的是当前线程的Looper对象。
现在来看一个例子,模拟从网络获取数据,加载到ListView的过程:
public class ListProgressDemo extends ListActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.listprogress);
((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View view) {
data = null;
data = new ArrayList<String>();
adapter = null;
showDialog(PROGRESS_DIALOG);
new ProgressThread(handler, data).start();
}
});
}
@Override
protected Dialog onCreateDialog(int id) {
switch(id) {
case PROGRESS_DIALOG:
return ProgressDialog.show(this, "",
"Loading. Please wait...", true);
default: return null;
}
}
private class ProgressThread extends Thread {
private Handler handler;
private ArrayList<String> data;
public ProgressThread(Handler handler, ArrayList<String> data) {
this.handler = handler;
this.data = data;
}
@Override
public void run() {
for (int i=0; i<8; i++) {
data.add("ListItem"); //后台数据处理
try {
Thread.sleep(100);
}catch(InterruptedException e) {
Message msg = handler.obtainMessage();
Bundle b = new Bundle();
b.putInt("state", STATE_ERROR);
msg.setData(b);
handler.sendMessage(msg);
}
}
Message msg = handler.obtainMessage();
Bundle b = new Bundle();
b.putInt("state", STATE_FINISH);
msg.setData(b);
handler.sendMessage(msg);
}
}
// 此处甚至可以不需要设置Looper,因为Handler默认就使用当前线程的Looper
private final Handler handler = new Handler(Looper.getMainLooper()) {
public void handleMessage(Message msg) { // 处理Message,更新ListView
int state = msg.getData().getInt("state");
switch(state){
case STATE_FINISH:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"加载完成!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
case STATE_ERROR:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"处理过程发生错误!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
default:
}
}
};
private ArrayAdapter<String> adapter;
private ArrayList<String> data;
private static final int PROGRESS_DIALOG = 1;
private static final int STATE_FINISH = 1;
private static final int STATE_ERROR = -1;
}
这个例子,我自己写完后觉得还是有点乱,要稍微整理才能看明白线程间交互的过程以及数据的前后变化。随后了解到AsyncTask类,相应修改后就很容易明白了!
2.3 AsyncTask
AsyncTask版:
((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View view) {
data = null;
data = new ArrayList<String>();
adapter = null;
//显示ProgressDialog放到AsyncTask.onPreExecute()里
//showDialog(PROGRESS_DIALOG);
new ProgressTask().execute(data);
}
});
private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> {
/* 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作,如在界面上显示一个进度条。*/
@Override
protected void onPreExecute() {
// 先显示ProgressDialog
showDialog(PROGRESS_DIALOG);
}
/* 执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。 */
@Override
protected Integer doInBackground(ArrayList<String>... datas) {
ArrayList<String> data = datas[0];
for (int i=0; i<8; i++) {
data.add("ListItem");
}
return STATE_FINISH;
}
/* 在doInBackground 执行完成后,onPostExecute 方法将被UI thread调用,
* 后台的计算结果将通过该方法传递到UI thread.
*/
@Override
protected void onPostExecute(Integer result) {
int state = result.intValue();
switch(state){
case STATE_FINISH:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"加载完成!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
case STATE_ERROR:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"处理过程发生错误!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
default:
}
}
当一个程序第一次启动时,Android会同时启动一个对应的主线程(Main Thread),主线程主要负责处理与UI相关的事件,如用户的按键事件,用户接触屏幕的事件以及屏幕绘图事件,并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线程。在开发Android应用时必须遵守单线程模型的原则: Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。
2.1 子线程更新UI
Android的UI是单线程(Single-threaded)的。为了避免拖住GUI,一些较费时的对象应该交给独立的线程去执行。如果幕后的线程来执行UI对象,Android就会发出错误讯息
CalledFromWrongThreadException。以后遇到这样的异常抛出时就要知道怎么回事了!
2.2 Message Queue
在单线程模型下,为了解决类似的问题,Android设计了一个Message Queue(消息队列), 线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。下面将对它们进行分别介绍:
1. Message
Message消息,理解为线程间交流的信息,处理数据后台线程需要更新UI,则发送Message内含一些数据给UI线程。
2. Handler
Handler处理者,是Message的主要处理者,负责Message的发送,Message内容的执行处理。后台线程就是通过传进来的Handler对象引用来sendMessage(Message)。而使用Handler,需要implement 该类的 handleMessage(Message)
方法,它是处理这些Message的操作内容,例如Update UI。通常需要子类化Handler来实现handleMessage方法。
3. Message Queue
Message Queue消息队列,用来存放通过Handler发布的消息,按照先进先出执行。
每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息:sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同:通过sendMessage发送的是一个message对象,会被Handler的handleMessage()函数处理;而通过post方法发送的是一个runnable对象,则会自己执行。
4. Looper
Looper是每条线程里的Message Queue的管家。Android没有Global的Message Queue,而Android会自动替主线程(UI线程)建立Message Queue,但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL,但调用Looper.myLooper()得到当前线程的Looper就有可能为NULL。
对于子线程使用Looper,API Doc提供了正确的使用方法:
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare(); //创建本线程的Looper并创建一个MessageQueue
mHandler = new Handler() {
public void handleMessage(Message msg) {
// process incoming messages here
}
};
Looper.loop(); //开始运行Looper,监听Message Queue
}
}
这个Message机制的大概流程:
1. 在Looper.loop()方法运行开始后,循环地按照接收顺序取出Message Queue里面的非NULL的Message。
2. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)到Message Queue,该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message,则调用该Message的target指向的Hander的dispatchMessage函数对Message进行处理。
在dispatchMessage方法里,如何处理Message则由用户指定,三个判断,优先级从高到低:
1) Message里面的Callback,一个实现了Runnable接口的对象,其中run函数做处理工作;
2) Handler里面的mCallback指向的一个实现了Callback接口的对象,由其handleMessage进行处理;
3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数,通过这个实现的handleMessage函数处理消息。
由此可见,我们实现的handleMessage方法是优先级最低的!
3. Handler处理完该Message (update UI) 后,Looper则设置该Message为NULL,以便回收!
在网上有很多文章讲述主线程和其他子线程如何交互,传送信息,最终谁来执行处理信息之类的,个人理解是最简单的方法——判断Handler对象里面的Looper对象是属于哪条线程的,则由该线程来执行!
1. 当Handler对象的构造函数的参数为空,则为当前所在线程的Looper;
2. Looper.getMainLooper()得到的是主线程的Looper对象,Looper.myLooper()得到的是当前线程的Looper对象。
现在来看一个例子,模拟从网络获取数据,加载到ListView的过程:
public class ListProgressDemo extends ListActivity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.listprogress);
((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View view) {
data = null;
data = new ArrayList<String>();
adapter = null;
showDialog(PROGRESS_DIALOG);
new ProgressThread(handler, data).start();
}
});
}
@Override
protected Dialog onCreateDialog(int id) {
switch(id) {
case PROGRESS_DIALOG:
return ProgressDialog.show(this, "",
"Loading. Please wait...", true);
default: return null;
}
}
private class ProgressThread extends Thread {
private Handler handler;
private ArrayList<String> data;
public ProgressThread(Handler handler, ArrayList<String> data) {
this.handler = handler;
this.data = data;
}
@Override
public void run() {
for (int i=0; i<8; i++) {
data.add("ListItem"); //后台数据处理
try {
Thread.sleep(100);
}catch(InterruptedException e) {
Message msg = handler.obtainMessage();
Bundle b = new Bundle();
b.putInt("state", STATE_ERROR);
msg.setData(b);
handler.sendMessage(msg);
}
}
Message msg = handler.obtainMessage();
Bundle b = new Bundle();
b.putInt("state", STATE_FINISH);
msg.setData(b);
handler.sendMessage(msg);
}
}
// 此处甚至可以不需要设置Looper,因为Handler默认就使用当前线程的Looper
private final Handler handler = new Handler(Looper.getMainLooper()) {
public void handleMessage(Message msg) { // 处理Message,更新ListView
int state = msg.getData().getInt("state");
switch(state){
case STATE_FINISH:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"加载完成!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
case STATE_ERROR:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"处理过程发生错误!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
default:
}
}
};
private ArrayAdapter<String> adapter;
private ArrayList<String> data;
private static final int PROGRESS_DIALOG = 1;
private static final int STATE_FINISH = 1;
private static final int STATE_ERROR = -1;
}
这个例子,我自己写完后觉得还是有点乱,要稍微整理才能看明白线程间交互的过程以及数据的前后变化。随后了解到AsyncTask类,相应修改后就很容易明白了!
2.3 AsyncTask
AsyncTask版:
((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View view) {
data = null;
data = new ArrayList<String>();
adapter = null;
//显示ProgressDialog放到AsyncTask.onPreExecute()里
//showDialog(PROGRESS_DIALOG);
new ProgressTask().execute(data);
}
});
private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> {
/* 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作,如在界面上显示一个进度条。*/
@Override
protected void onPreExecute() {
// 先显示ProgressDialog
showDialog(PROGRESS_DIALOG);
}
/* 执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。 */
@Override
protected Integer doInBackground(ArrayList<String>... datas) {
ArrayList<String> data = datas[0];
for (int i=0; i<8; i++) {
data.add("ListItem");
}
return STATE_FINISH;
}
/* 在doInBackground 执行完成后,onPostExecute 方法将被UI thread调用,
* 后台的计算结果将通过该方法传递到UI thread.
*/
@Override
protected void onPostExecute(Integer result) {
int state = result.intValue();
switch(state){
case STATE_FINISH:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"加载完成!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
case STATE_ERROR:
dismissDialog(PROGRESS_DIALOG);
Toast.makeText(getApplicationContext(),
"处理过程发生错误!",
Toast.LENGTH_LONG)
.show();
adapter = new ArrayAdapter<String>(getApplicationContext(),
android.R.layout.simple_list_item_1,
data );
setListAdapter(adapter);
break;
default:
}
}
更多相关文章
- android Http请求的线程操作设计模板
- 【边做项目边学Android】异常处理:android.os.NetworkOnMainThrea
- Android中Math取整的三个方法
- Android Studio启动时卡在Fetching Android SDK 以及导入Eclipse
- 总结线程交互
- Android中对象池的使用