Android单线程模型

当第一次启动一个Android程序时，Android会自动创建一个称为“main”主线程的线程。这个主线程（也称为UI线程）很重要，因为它负责把事件分派到相应的控件，其中就包括屏幕绘图事件，它同样是用户与Andriod控件交互的线程。比如，当你在屏幕上按下一个按钮后，UI线程会把这个事件分发给刚按得那个按钮，紧接着按钮设置它自身为被按下状态并向事件队列发送一个无效（invalidate）请求。UI线程会把这个请求移出事件队列并通知按钮在屏幕上重新绘制自身。

Android单线程模型会在没有考虑到它的影响的情况下引起Android应用程序性能低下，因为所有的任务都在同一个线程中执行，如果执行一些耗时的操作，如访问网络或查询数据库，会阻塞整个用户界面。当在执行一些耗时的操作的时候，不能及时地分发事件，包括用户界面重绘事件。从用户的角度来看，应用程序看上去像挂掉了。更糟糕的是，如果阻塞应用程序的时间过长（现在大概是5秒钟）Android会向用户提示一些信息，即打开一个“应用程序没有相应（application not responding）”的对话框。

如果你想知道这有多糟糕，写一个简单的含有一个按钮的程序，并为按钮注册一个单击事件，并在事件处理器中调用这样的代码 Thread.sleep(2000)。在按下这个按钮这后恢复按钮的正常状态之前，它会保持按下状态大概2秒钟。如果这样的情况在你编写的应用程序中发生，用户的第一反应就是你的程序运行很慢。为了避免这样的情况，Android设置了一个5秒的超时时间，一旦用户的事件由于主线程阻塞而超过5秒钟没有响应，Android会弹出一个应用程序没有响应的对话框。
:D :D :D :D :D :D :D :D :D :D :D :D :D
下面将通过一个案例来演示这种情况：
[color=red]1.首先，需要选择一个天气查询的服务接口，目前可供选择的接口很多，诸如YAHOO的天气API和Google提供的天气API。本文将选择GOOGLE 的天气查询API。该接口提供了多种查询方式，可以通过指定具体城市的经纬度进行查询，也可以通过城市名称进行查询。
2.用户在输入框内输入需要查询的城市名称，然后点击查询按钮
3.当用户点击查询按钮后，使用已经内置在Android SDK中的HttpClient API来调用GOOGLE 的天气查询API，然后解析返回的指定城市的天气信息，并把该天气信息显示在Title上[/color]
我们需要在onClick方法中创建一个新的子线程来负责调用GOOGLE API来获得天气数据。刚接触Android的开发者最容易想到的方式就是如下：

public void onClick(View v) {
 //创建一个子线程执行耗时的从网络上获取天气信息的操作
new Thread() {
@Override

?public void run() {

//获得用户输入的城市名称

String city = editText.getText().toString();

//调用Google 天气API查询指定城市的当日天气情况

String weather = getWetherByCity(city);

//把天气信息显示在title上

setTitle(weather);
}}.start();
}

public String getWetherByCity(String city) {

HttpClient httpClient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();

HttpGet httpGet = new HttpGet(GOOGLE_API_URL + city);

try {
HttpResponse response = httpClient.execute(httpGet, localContext);
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
httpGet.abort();
} else {
HttpEntity httpEntity = response.getEntity();
return parseWeather(httpEntity.getContent());
}
} catch (Exception e) 
{
Log.e("WeatherReport", "Failed to get weather", e);

} finally {
httpClient.getConnectionManager().shutdown();
}
return NETWORK_ERROR;
}

但是很不幸，你会发现Android会提示程序由于异常而终止。为什么在其他平台上看起来很简单的代码在Android上运行的时候依然会出错呢？如果你观察LogCat中打印的日志信息就会发现这样的错误日志：
[color=red]android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
从错误信息不难看出Android禁止其他子线程来更新由UI thread创建的试图[/color]。本例中显示天气信息的title实际是就是一个由UI thread所创建的TextView，所以参试在一个子线程中去更改TextView的时候就出错了。这显示违背了单线程模型的原则：Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行
在单线程模型下，为了解决类似的问题，Android设计了一个Message Queue(消息队列)，线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。下面将对它们进行分别介绍：

l??Message Queue

Message Queue是一个消息队列，用来存放通过Handler发布的消息。消息队列通常附属于某一个创建它的线程，可以通过Looper.myQueue()得到当前线程的消息队列。Android在第一启动程序时会默认会为UI thread创建一个关联的消息队列，用来管理程序的一些上层组件，activities，broadcast receivers 等等。你可以在自己的子线程中创建Handler与UI thread通讯。

Handler
通过Handler你可以发布或者处理一个消息或者是一个Runnable的实例。每个Handler都会与唯一的一个线程以及该线程的消息队列管理。当你创建一个新的 Handler时候，默认情况下，它将关联到创建它的这个线程和该线程的消息队列。也就是说，如果你通过Handler发布消息的话，消息将只会发送到与它关联的这个消息队列，当然也只能处理该消息队列中的消息。

主要的方法有：

1)public final boolean sendMessage(Message msg)

把消息放入该Handler所关联的消息队列，放置在所有当前时间前未被处理的消息后。

2)public void handleMessage(Message msg)

关联该消息队列的线程将通过调用Handler的handleMessage方法来接收和处理消息，通常需要子类化Handler来实现handleMessage。

Looper
Looper 扮演着一个Handler和消息队列之间通讯桥梁的角色。程序组件首先通过Handler把消息传递给Looper，Looper把消息放入队列。 Looper也把消息队列里的消息广播给所有的Handler，Handler接受到消息后调用handleMessage进行处理。

1)可以通过Looper类的静态方法Looper.myLooper得到当前线程的Looper实例，如果当前线程未关联一个Looper实例，该方法将返回空。

2)可以通过静态方法Looper. getMainLooper方法得到主线程的Looper实例

线程，消息队列，Handler，Looper之间的关系可以通过一个图来展示：

在了解了消息队列及其相关组件的设计思想后，我们将把天气预报的案例通过消息队列来重新实现：

private EditText editText;

private Handler messageHandler;
 @Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

editText = (EditText) findViewById(R.id.weather_city_edit);

Button button = (Button) findViewById(R.id.goQuery);

button.setOnClickListener(this);

//得到当前线程的Looper实例，由于当前线程是UI线程也可以通过Looper.getMainLooper()得到

Looper looper = Looper.myLooper();

//此处甚至可以不需要设置Looper，因为 Handler默认就使用当前线程的Looper

messageHandler = new MessageHandler(looper);

}
@Override

public void onClick(View v) {

//创建一个子线程去做耗时的网络连接工作

new Thread() {
@Override

public void run() {

 //活动用户输入的城市名称
String city = editText.getText().toString();

//调用Google 天气API查询指定城市的当日天气情况

 String weather = getWetherByCity(city);

//创建一个Message对象，并把得到的天气信息赋值给Message对象

 Message message = Message.obtain();

 message.obj = weather;

//通过Handler发布携带有天气情况的消息
messageHandler.sendMessage(message);

}
}.start();

}
//子类化一个Handler

class MessageHandler extends Handler {

public MessageHandler(Looper looper) {

super(looper);

}

@Override

public void handleMessage(Message msg) {

//处理收到的消息，把天气信息显示在title上

setTitle((String) msg.obj);

}
}

通过消息队列改写过后的天气预报程序已经可以成功运行，因为Handler的handleMessage方法实际是由关联有该消息队列的UI thread调用，而在UI thread中更新title并没有违背Android的单线程模型的原则。

2.3 AsyncTask

虽然借助消息队列已经可以较为完美的实现了天气预报的功能，但是你还是不得不自己管理子线程，尤其当你的需要有一些复杂的逻辑以及需要频繁的更新UI的时候，这样的方式使得你的代码难以阅读和理解。

幸运的是Android另外提供了一个工具类：AsyncTask。它使得UI thread的使用变得异常简单。它使创建需要与用户界面交互的长时间运行的任务变得更简单，不需要借助线程和Handler即可实现。

1）子类化AsyncTask

2)实现AsyncTask中定义的下面一个或几个方法

onPreExecute(), 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。

doInBackground(Params...), 将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。

3. onProgressUpdate(Progress...),在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。

4. onPostExecute(Result), 在doInBackground 执行完成后，onPostExecute 方法将被UI thread调用，后台的计算结果将通过该方法传递到UI thread.

为了正确的使用AsyncTask类，以下是几条必须遵守的准则：

1)? ?Task的实例必须在UI thread中创建

2)? ?execute方法必须在UI thread中调用

3)? ?不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法

4)? ?该task只能被执行一次，否则多次调用时将会出现异常

下面我们将通过AsyncTask并且严格遵守上面的4条准则来改写天气预报的例子：

? ? public void onCreate(Bundle savedInstanceState) {

? ?? ? super.onCreate(savedInstanceState);

? ?? ? setContentView(R.layout.main);

? ?? ? editText = (EditText) findViewById(R.id.weather_city_edit);

? ?? ? Button button = (Button) findViewById(R.id.goQuery);

? ?? ? button.setOnClickListener(this);

? ? }

? ? public void onClick(View v) {

? ?? ? //获得用户输入的城市名称

? ?? ? String city = editText.getText().toString();

? ? //必须每次都重新创建一个新的task实例进行查询，否则将提示如下异常信息

? ? //the task has already been executed (a task can be executed only once)

? ?? ? new GetWeatherTask().execute(city);

? ? }

? ? class GetWeatherTask extends AsyncTask<String, Integer, String> {

? ?? ? @Override

? ?? ? protected String doInBackground(String... params) {

? ?? ?? ???String city = params[0];

? ?? ?? ???//调用Google 天气API查询指定城市的当日天气情况

? ?? ?? ???return getWetherByCity(city);

? ?? ? }

? ?? ? protected void onPostExecute(String result) {

? ?? ?? ???//把doInBackground处理的结果即天气信息显示在title上

? ?? ?? ???setTitle(result);

? ?? ? }

? ? }

注意这行代码：new GetWeatherTask().execute(city); 值得一提的是必须每次都重新创建一个新的GetWeatherTask来执行后台任务，否则Android会提示“a task can be executed only once”的错误信息。

经过改写后的程序不仅显得非常的简洁，而且还减少了代码量，大大增强了可读性和可维护性。因为负责更新UI的onPostExecute方法是由UI thread调用，所以没有违背单线程模型的原则。良好的AsyncTask设计大大降低了我们犯错误的几率。


:D :D :D :D :D :D :D :D :D :D :D :D :D
1 Android进程
当一个程序第一次启动的时候，Android会启动一个LINUX进程和一个主线程。默认的情况下，所有该程序的组件都将在该进程和线程中运行。同时，Android会为每个应用程序分配一个单独的LINUX用户。Android会尽量保留一个正在运行进程，只在内存资源出现不足时，Android才会尝试停止一些进程从而释放足够的资源给其他新的进程使用， 也能保证用户正在访问的当前进程有足够的资源去及时的响应用户的事件。Android会根据进程中运行的组件类别以及组件的状态来判断该进程的重要性，Android会首先停止那些不重要的进程。按照重要性从高到低一共有五个级别：

前台进程
前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的，当内存低到根本连他们都不能运行的时候。一般来说， 在这种情况下，设备会进行内存调度，中止一些前台进程来保持对用户交互的响应。

可见进程

可见进程不包含前台的组件但是会在屏幕上显示一个可见的进程是的重要程度很高，除非前台进程需要获取它的资源，不然不会被中止。
服务进程

运行着一个通过startService() 方法启动的service，这个service不属于上面提到的2种更高重要性的。service所在的进程虽然对用户不是直接可见的，但是他们执行了用户非常关注的任务（比如播放mp3，从网络下载数据）。只要前台进程和可见进程有足够的内存，系统不会 回收他们。
后台进程

运行着一个对用户不可见的activity（调用过 onStop() 方法).这些进程对用户体验没有直接的影响，可以在服务进程、可见进程、前台进 程需要内存的时候回收。通常，系统中会有很多不可见进程在运行，他们被保存在LRU (least recently used) 列表中，以便内存不足的时候被第一时间回收。如果一个activity正 确的执行了它的生命周期，关闭这个进程对于用户体验没有太大的影响。

l 空进程

未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓 存的平衡。

因此一个要进行耗时工作的activity最好启动一 个service来做这个工作，而不是开启一个子进程――特别 是这个操作需要的时间比activity存在的时间还要长的时 候。例如，在后台播放音乐，向网上上传摄像头拍到的图片，使用service可 以使进程最少获取到“服务进程”级别的重要级，而不用考虑activity目前是什么状态。broadcast receivers做费时的工作的时候，也应该启用一个服务而不是开一个线程。


2 单线程模型
当一个程序第一次启动时，Android会同时启动一个对应的 主线程（Main Thread），主线程主要负责处理与UI相关的事件，如：用户的按键事件，用户接触屏幕的事件以及屏幕绘图事 件，并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线 程。在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。 UI操作，如UI刷新
那么什么线程安全的？
定义不统一，可以简单的理解为：
1 可以被多个程序线程调用，这些线程之间没有非预期的互交。
2 可以同时被多个线程调用，而调用者不需要任何动作（来确保线程的安全性）。
所以说如果在其他线程中调用UI线程中的组件，可能是UI主线程受到伤害。
3 当多个线程访问一个类时，如果不用考虑这些线程在运行时环境下的调度和交替执行，并且不需要额外的同步及在调用方代码不必作其他的协调，这个类的行为仍然是正确的，那么称这个类是线程安全的。

通常可以使用handler来完成UI线程的更新操作。