Android线程详解
现在大多数的移动设备已经变得越来越快,但是它们其实也不算是非常快。如果你想让你的APP既可以承受一些繁杂的工作而又不影响用户体验的话,那么必须把任务并行执行。在Android上,我们使用线程。
端一杯咖啡,然后仔细阅读这篇文章。我会给大家介绍一下线程的概念,还有在Java中怎么使用线程,在线程中怎么使用Handler等。
如果需要使用异步处理或者并行任务的话,那么你一定会用到线程。
什么是线程?
线程或者线程执行本质上就是一串命令(也是程序代码),然后我们把它发送给操作系统执行。
一般来说,我们的CPU在任何时候一个核只能处理一个线程。多核处理器(目前大多数Android设备已经都是多核)顾名思义,就是可以同时处理多线程(通俗地讲就是可以同时处理多件事)。
多核处理与单核多任务处理的实质
上面我说的是一般情况,并不是所有的描述都是一定正确的。因为单核也可以用多任务模拟出多线程。
每个运行在线程中的任务都可以分解成多条指令,而且这些指令不用同时执行。所以,单核设备可以首先切换到线程1去执行指令1A,然后切换到线程2去执行指令2A,接着返回到线程1再去执行1B、1C、1D,然后继续切换到线程2,执行2B、2C等等,以此类推。
这个线程之间的切换十分迅速,以至于在单核的设备中也会发生。几乎所有的线程都在相同的时间内进行任务处理。其实,这都是因为速度太快造成的假象,就像电影《黑客帝国》里的特工Brown一样,可以变幻出很多的头和手。
接下来我们来看一些代码。
Java核心里的线程
在Java中,如果要想做平行任务处理的话,会在Runnable里面执行你的代码。可以继承Thread类,或者实现Runnable接口:
// Version 1
public
class
IAmAThread
extends
Thread {
public
IAmAThread() {
super
(
"IAmAThread"
);
}
@Override
public
void
run() {
// your code (sequence of instructions)
}
}
// to execute this sequence of instructions in a separate thread.
new
IAmAThread().start();
// Version 2
public
class
IAmARunnable
implements
Runnable {
@Override
public
void
run() {
// your code (sequence of instructions)
}
}
// to execute this sequence of instructions in a separate thread.
IAmARunnable myRunnable =
new
IAmARunnable();
new
Thread(myRunnable).start();
这两个方法基本上是一样的。第一个版本是创建一个Thread类,第二个版本是需要创建一个Runnable对象,然后也需要一个Thread类来调用它。
第二个版是通常建议使用的方法。这也是一个很大的主题了,超过了本文的范围,以后会再做讨论。
Android上的线程
无论何时启动APP,所有的组件都会运行在一个单独的线程中(默认的)——叫做主线程。这个线程主要用于处理UI的操作并为视图组件和小部件分发事件等,因此主线程也被称作UI线程。
如果你在UI线程中运行一个耗时操作,那么UI就会被锁住,直到这个耗时操作结束。对于用户体验来说,这是非常糟糕的!这也就是为什么我们要理解Android上的线程机制了。理解这些机制就可以把一些复杂的工作移动到其它的线程中去执行。如果你在UI线程中运行一个耗时的任务,那么很有可能会发生ANR(应用无响应),这样用户就会很快地结束掉你的APP。
Android和Java一样,它支持使用Java里面的Thread类来进行一步任务处理。所以可以轻松地像上面Java的例子一样来使用Android上的线程,不过那好像还是有点困难。
为什么在Android上使用标准Java的线程会困难呢?
其实平行任务处理没有想象中的那么简单,你必须在多线程中保证并发,就像伟大的Tim Bray说的那样:ordinary humans can’t do concurrency at scale (or really at all) …
特别对于Android来说,以下这些功能就略显臃肿:
- 异步对于UI线程来说是一个主要的PITA(如果你需要在后台线程中向主线程更新界面,那么你就会用到)。
- 如果屏幕方向或者屏幕配置改变的话,就会出现一些更加奇怪的现象。因为改变屏幕方向,会引起Activity重建(所以后台线程就需要去改变被销毁的Activity的状态了,而如果后台线程不是在UI线程之上的话,那情况会更加复杂,原因如条件1)。
- 对于线程池来说,没有默认的处理方式。
- 取消线程操作需要自定义代码实现。
那么在Android上怎么进行任务并发处理呢?
你可能听过一些Android上一些常见的名词:
1、Handler
这就是我们今天要讨论的详细主题。
2、AsyncTask
使用AsyncTask是在Android上操作线程最简单的方式,也是最容易出错的方式。
3、IntentService
这种方式需要写更多的代码,但是这是把耗时任务移动到后台的很好的方式,也是我最喜欢的方式。配上使用一个EventBus机制的框架如Otto,这样的话实现IntentService就非常简单了。
4、Loader
关于处理异步任务,还有很多事情需要做,比如从数据库或者内容提供者那里处理一些数据。
5、Service
如果你曾经使用过Service的话,你应该知道这里会有一点误区,其中一个常见的误解就是服务是运行在后台线程的。其实不是!看似运行在后台是因为它们不与UI组件关联,但是它们(默认)是运行在UI线程上的……所以默认运行在UI线程上,甚至在上面没有UI部件。
如果想要把服务运行在后台线程中,那么必须自定义一个线程,然后把操作代码都运行在那个线程中(与上面提到的方法很类似)。事实上你应该使用IntentService实现,但是这不是本文讨论的主题。
Android上的Handler
以下是从 Android developer documentation for Handlers:中摘选的一段话:
> A Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue. Each Handler instance is associated with a single thread and that thread’s message queue. When you create a new Handler, it is bound to the thread/message queue of the thread that is creating it — from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.
为了更好地了解这个概念,也许你需要去看看什么是Message Queues。
消息队列
在线程里基本都有一个叫做“消息队列”的东西,它负责线程间通信。这是一种设计模式,所有控制指令或者内容在线程间传递。
消息队列如同它的名字那样,对于线程来说,它就是一个指令队列。这里我们还可以做一些更酷的事:
- 定时消息和线程在某个时间点才执行。
- 需要在另一个线程中去添加入队动作,而不是在本线程中。
注意:这里说的“消息”和Runnable对象、指令队列的概念是一样的。
回到Android上的Handler……如果你仔细阅读的话,可以看到文档是这样说的:
> A Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue.
所以Handler可以让你给线程队列发消息:
> Each Handler instance is associated with a single thread and that thread’s message queue.
一个Handler对象只能和一个线程关联:
> When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it
所以一个Handler到底和哪个线程关联呢?就是创造它的线程。
> — from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.、
在我们了解这些知识后,请继续看……
小贴士: 这里有几点可能你还不知道。每个线程都和一个Handler类实例绑定,而且可以和别的线程一起运行,相互通信。
还有一个小建议(如果用过AsyncTask的话),AsyncTask内部也是使用Handler进行处理的,只是不是运行在UI线程而已,它会提供一个channel来和UI线程通信,使用postExecute方法即可实现。
这还挺酷的,那怎么创建Handler呢?
有两种方式:
- 使用默认的构造方法:new Handler()。
- 使用带参的构造方法,参数是一个Runnable对象或者回调对象。
Handler里面有什么实用的API吗?
请记住:
- Handler只是简单往消息队列中发送消息而已(或者使用post方式)
- 它们有更方便的方法可以帮助与UI线程通信。
如果你现在看看Handler的API,可以清楚看到这几个方法:
- post
- postDelayed
- postAtTime
代码示例
这里的代码都是很基础的,不过你可以好好看看注释。
示例1:使用Handler的“post”方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
public class TestActivity extends Activity {
// ...
// all standard stuff
@Override
public void onCreate(Bundle savedInstanceState) {
// ...
// all standard stuff
// we're creating a new handler here
// and we're in the UI Thread (default)
// so this Handler is associated with the UI thread
Handler mHandler = new Handler();
// I want to start doing something really long
// which means I should run the fella in another thread.
// I do that by sending a message - in the form of another runnable object
// But first, I'm going to create a Runnable object or a message for this
Runnable mRunnableOnSeparateThread = new Runnable() {
@Override
public void run () {
// do some long operation
longOperation();
// After mRunnableOnSeparateThread is done with it's job,
// I need to tell the user that i'm done
// which means I need to send a message back to the UI thread
// who do we know that's associated with the UI thread?
mHandler.post( new Runnable(){
@Override
public void run(){
// do some UI related thing
// like update a progress bar or TextView
// ....
}
});
}
};
// Cool but I've not executed the mRunnableOnSeparateThread yet
// I've only defined the message to be sent
// When I execute it though, I want it to be in a different thread
// that was the whole point.
new Thread(mRunnableOnSeparateThread).start();
}
}
|
如果根本就没有Handler对象,回调post方法会比较难办。
示例2:使用postDelayed方法
近期本站新介绍的特性中,我每次都要模拟EditText的自动完成功能,每次文字改变后都会触发一个API的调用,从服务器中检索数据。
我想减少APP调用API的次数,所以决定使用Handler的postDelayed方法来实现这个功能。
本例不针对平行处理,只是关于Handler给消息队列发送消息还有安排消息在未来的某一点执行等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
// the below code is inside a TextWatcher
// which implements the onTextChanged method
// I've simplified it to only highlight the parts we're
// interested in
private long lastChange = 0 ;
@Override
public void onTextChanged( final CharSequence chars,
int start, int before, int count) {
// The handler is spawned from the UI thread
new Handler().postDelayed(
// argument 1 for postDelated = message to be sent
new Runnable() {
@Override
public void run() {
if (noChangeInText_InTheLastFewSeconds()) {
searchAndPopulateListView(chars.toString()); // logic
}
}
},
// argument 2 for postDelated = delay before execution
300 );
lastChange = System.currentTimeMillis();
}
private boolean noChangeInText_InTheLastFewSeconds() {
return System.currentTimeMillis() - lastChange >= 300
}
|
最后我就把“postAtTime”这个方法作为联系留给读者们了,掌握Handler了吗?如果是的话,那么可以尽情使用线程了。
1. Android进程
在了解Android线程之前得先了解一下Android的进程。当一个程序第一次启动的时候,Android会启动一个LINUX进程和一个主线程。默认的情况下,所有该程序的组件都将在该进程和线程中运行。同时,Android会为每个应用程序分配一个单独的LINUX用户。Android会尽量保留一个正在运行进程,只在内存资源出现不足时,Android会尝试停止一些进程从而释放足够的资源给其他新的进程使用, 也能保证用户正在访问的当前进程有足够的资源去及时地响应用户的事件。Android会根据进程中运行的组件类别以及组件的状态来判断该进程的重要性,Android会首先停止那些不重要的进程。按照重要性从高到低一共有五个级别:
- 前台进程
前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的,当内存低到根本连他们都不能运行的时候。一般来说, 在这种情况下,设备会进行内存调度,中止一些前台进程来保持对用户交互的响应。 - 可见进程
可见进程不包含前台的组件但是会在屏幕上显示一个可见的进程是的重要程度很高,除非前台进程需要获取它的资源,不然不会被中止。 - 服务进程
运行着一个通过startService() 方法启动的service,这个service不属于上面提到的2种更高重要性的。service所在的进程虽然对用户不是直接可见的,但是他们执行了用户非常关注的任务(比如播放mp3,从网络下载数据)。只要前台进程和可见进程有足够的内存,系统不会回收他们。 - 后台进程
运行着一个对用户不可见的activity(调用过 onStop() 方法).这些进程对用户体验没有直接的影响,可以在服务进程、可见进程、前台进 程需要内存的时候回收。通常,系统中会有很多不可见进程在运行,他们被保存在LRU (least recently used) 列表中,以便内存不足的时候被第一时间回收。如果一个activity正 确的执行了它的生命周期,关闭这个进程对于用户体验没有太大的影响。 - 空进程
未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存,缩短下次程序需要重新使用的启动时间。系统经常中止这些进程,这样可以调节程序缓存和系统缓存的平衡。
Android 对进程的重要性评级的时候,选取它最高的级别。另外,当被另外的一个进程依赖的时候,某个进程的级别可能会增高。一个为其他进程服务的进程永远不会比被服务的进程重要级低。因为服务进程比后台activity进程重要级高,因此一个要进行耗时工作的activity最好启动一个service来做这个工作,而不是开启一个子进程――特别是这个操作需要的时间比activity存在的时间还要长的时候。例如,在后台播放音乐,向网上上传摄像头拍到的图片,使用service可以使进程最少获取到“服务进程”级别的重要级,而不用考虑activity目前是什么状态。broadcast receivers做费时的工作的时候,也应该启用一个服务而不是开一个线程。
2. 单线程模型
当一个程序第一次启动时,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组件进行信息交换。下面将对它们进行分别介绍:
对于子线程使用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,以便回收!
现在来看一个例子,模拟从网络获取数据,加载到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
- ((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另外提供了一个工具类:AsyncTask。它使得UI thread的使用变得异常简单。它使创建需要与用户界面交互的长时间运行的任务变得更简单,不需要借助线程和Handler即可实现。
转自:http://blog.jobbole.com/73267/
http://android.blog.51cto.com/268543/343823
Android线程详解相关推荐
- android任务 进程 线程详解,Android任务、进程、线程详解
singleTop模式,基本上于standard分歧,仅正在请求的Activity反好位于栈顶时,无所区别.此时,配放成singleTop的Activity,不再会构制新的实例加入到Task栈外,而是 ...
- Android Service 详解一:概述
一个Service是没有界面且能长时间运行于后台的应用组件.其它应用的组件可以启动一个服务运行于后台,即使用户切换到另一个应用也会继续运行.另外,一个组件可以绑定到一个service来进行交互,即使这 ...
- Android 动画详解-思维导图版
转载请注明链接: https://blog.csdn.net/feather_wch/article/details/81503233 涉及视图动画(补间动画.逐帧动画).属性动画三种动画的使用方法, ...
- android service是什么,Android service是什么 Android service详解
Android service是什么 Android service详解 时间:2017-04-06 来源:Android开发学习网 什么是Android Service? service是A ...
- Android 多线程详解
Android 多线程详解 一.多线程介绍 在学习多线程之前我们首先要了解几个与多线程有关的概念. 进程:进程指正在运行的程序.确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中 ...
- Android冷启动详解
Android冷启动详解 冷启动: 热启动: APP冷启动详解 冷启动优化 本文主要讲Android app 冷.热启动流程,已经启动优化. 冷启动: 当应用启动时,后台没有该应用的进程,这时系统会重 ...
- Android touch详解(2) touch bringup
Android touch详解(2) touch bringup 前言 了解需求 电路图 驱动移植 1. 添加touch driver 2. 修改Makefile 3. kconfig 4. .ini ...
- Android开发详解:第4章《UI 控件》
Android开发详解:第4章<UI 控件> 控件是Android程序设计的基本组成单位,通过使用控件可以高效地开发Android应用程序.所以熟练掌握控件的使用是合理.有效地进行Andr ...
- Android Drawable 详解
Android Drawable 详解 @(Technical)[Android, Drawable, StateListDrawable, LayerDrawable, AnimationDrawa ...
最新文章
- 深度学习中的图像分割:方法和应用
- flutter 真机无法调试 sdk报错_Flutter - 不一样的跨平台解决方案
- linux 查找 jdk 安装路径
- Linux信号的使用
- 测试Spring Boot有条件的合理方式
- C++总结8——shared_ptr和weak_ptr智能指针
- 从零开始学习PYTHON3讲义(二)把Python当做计算器
- 十年后,你在元宇宙中的一天是什么样?
- 判断单链表是否存在环及环的入口点
- python工厂模式看不懂_python模式 工厂模式原理及实例详解
- [WPF] 托盘菜单的基本功能实现
- ROS教程之读取激光雷达(sick_tim561)数据
- 网络传输性能netperf测试方法和下载
- Label Matrix v8 怎样做二次开发
- 离线语音合成使用——科大讯飞or云知音or百度语音
- postgresql standard_conforming_strings参数
- [数学基础知识] Cramér‘s V 相关系数和Python算法实现
- 仿写微信公众号添加自定义菜单 并给后台存数据
- 2021秋招河南联通面经
- lager_error_logger_h dropped ~p messages in the last second that exceeded the limit of ~p messages/s