（1）主线程和ANR
主线程：UI线程，界面的修改只能在主线程中，其它线程对界面进行修改会造成异常。这样就解决了多线程竞争UI资源的问题。
一旦主线程的代码阻塞，界面将无法响应，这种行为就是Application Is Not Respond（ANR），应用失去响应。
如果主线程中某个事件操作时间超过5秒没有得到响应，Android可能会弹出一个应用程序没有响应的对话框。activity可能会被杀掉。
下面用实例来说明ANR，demo如下，这个时候按钮就会失去响应
private Button btn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn=(Button)findViewById(R.id.button1);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
//主线程耗时操作
Thread.sleep(10*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
ANR的成因和避免：1，耗时操作是不可避免的，如网络连接和网络数据的获取，对存储器的读写，大量数据的计算，任何一种操作都有可能占用时间，例如网络不稳定，磁盘在忙，cpu被占用。 2，UI线程是负责事件的监听和绘图，因此必须保证UI线程能够随时响应用户的需求，任何对UI线程的阻塞无论时间长短都会影响用户的体验或是导致anr，UI线程中的操作要尽量的短小，耗时操作（网络连接数据访问等）要在单独的线程中完成。
（2）Android的消息机制，由于android中不可避免的要进行耗时操作，主线程阻塞会影响与用户的交互，需要一种机制能够通知主线程更新界面，这就是消息机制，Looper消息机制（主线程视角看消息机制，消息队列，looper循环读取消息，进行消息的回调），Handler消息机制（编程视角看消息机制）。下图就是Looper和Handler处理消息机制的图
对消息队列的操作只能通过Handler来进行，当Handler的sendMessage方法时就会发送一个消息，主线程Looper就会发现消息队列的改变，并响应这个消息，消息被处理后会从队里移除，处理响应消息也是由Handler来处理，handleMessage方法。这个方法是运行在主线程中的。handler中常用的方法，void handleMessage（）方法，消息发送后通过这个方法来处理，这个方法需要重写。boolean sendEmptyMessage（int what）方法，只发送一个what值的消息。boolean sendMesssage（Message message）发送消息到handler，在handler中处理消息，sendMessageDelayed（Message msg ,long s）,removeMessages(int what)删除message/取消定时的message。
下面以一个demo来说明Handler和message的用法，demo如下
package com.example.handlerdemo;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private static final int MESSAGE_OK=1;
private static final int MESSAGE_CANCLE=2;
private static final int MESSAGE_ARG1=3;
private static final int MESSAGE_ARG2=4;
private Handler handler=new Handler(){
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case MESSAGE_OK:
txt.setText("ok");
break;
case MESSAGE_CANCLE:
if(msg.arg1==MESSAGE_ARG1){
txt.setText("cancle"+"by user");
}else{
txt.setText("cancle"+"by system");
}
break;
default:
break;
}
};
};
private Button btn_ok;
private Button btn_cancle;
private TextView txt;
private Button btn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn_cancle=(Button)findViewById(R.id.btn_cancle);
btn_ok=(Button)findViewById(R.id.btn_ok);
btn=(Button)findViewById(R.id.btn);
txt=(TextView) findViewById(R.id.txt);
btn_ok.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
/*Message msg=Message.obtain();//获取message实例的正规方法
msg.what=MESSAGE_OK;
handler.sendMessage(msg);
handler.sendEmptyMessage(MESSAGE_OK);*///sendEmptyMessage的方法
handler.sendEmptyMessageDelayed(MESSAGE_OK, 10000);//延时发送消息,还有定时发送消息的方法
}
});
btn_cancle.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Message msg=Message.obtain();
msg.what=MESSAGE_CANCLE;
msg.arg1=MESSAGE_ARG1;//message的参数。
handler.sendMessage(msg);
}
});
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
handler.removeMessages(MESSAGE_OK);//取消发送消息
}
});
}
}
在使用Message和Looper的时候我们还需要注意一下几点：1，Looper和MessageQueue是在主线程创建时就会创建的，新建线程的时候是不会默认创建的，一般情况下我们是不会去直接访问者两个对象。2，Handler必须在有Looper实例的情况下才能实例化，在新建的线程中默认是不能被实例化的，否则就会出错。3，子线程默认情况下是没有实例化Looper和MessageQueue对象的。
（3）Thread和Handler，handler的sendmessage()方法可以运行在其它线程中，这样我们就何以通过Thread和Handler的结合来解决耗时操作的问题，一下我们用一个动态显示进度条控件的demo来说明效果如下图
代码如下：
package com.example.handlerandthreaddemo;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnStart;
private TextView tvDownLoad;
private ProgressBar pbDownLoad;
private static final int MESSAGE_NUMBER=1;
private int i=0;
private Handler handler=new Handler(){
public void handleMessage(android.os.Message msg) {
if(msg.what==MESSAGE_NUMBER){
pbDownLoad.setProgress(i);
tvDownLoad.setText("下载进度"+i+"%");
}
};
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnStart=(Button) findViewById(R.id.btnStart);
tvDownLoad=(TextView)findViewById(R.id.txtDownLoad);
pbDownLoad=(ProgressBar) findViewById(R.id.pbDownLoad);
btnStart.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(){
public void run() {
while(i<100){
try {
sleep(500);
i++;
Message msg=Message.obtain();
msg.what=MESSAGE_NUMBER;
handler.sendMessage(msg);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
}.start();
}
});
}
}
（4）AsyncTask线程间的异步通信。
AsyncTask也是一种异步加载机制，使用时要注意一下几点：1，Task的实例必须在主线程中创建，2，execute（）方法必须在主线程中调用，3，不要调用onpreExecute（），doinbackground（），onprogressUpdate（），onpostExecute（）等方法。4，该实例化后的task只能被执行一次，重复调用会出现异常。
AsyncTask几种常用方法：onpreExecute（）方法，该方法在执行实际的后台之前被主线程调用；doInBackground()方法，是执行耗时操作，执行在后台的进程中，是抽象方法，子类必须重写，在这个方法中调用publishprogress（）方法来实现实时跟新的任务进行；onProgressUpdate（）方法在publisprogress（）方法被调用后，UI线程调用此方法。onPostExecute（）方法是在后台操作完成后来跟新界面。下面以一个实例和效果图来说明
代码
package com.example.asynctask;
import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnStart,btn;
private TextView tv;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn=(Button) findViewById(R.id.button2);
btnStart=(Button)findViewById(R.id.button1);
tv=(TextView) findViewById(R.id.textView1);
btnStart.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
MyAsyncTask myTask=new MyAsyncTask();
myTask.execute();
}
});
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
}
class MyAsyncTask extends AsyncTask<Void, Void, Void>{
@Override
protected void onPreExecute() {
tv.setText("之前");
super.onPreExecute();
}
@Override
protected void onProgressUpdate(Void... values) {
super.onProgressUpdate(values);
String s=tv.getText().toString();
tv.setText(s+"+");
}
@Override
protected Void doInBackground(Void... params) {
try {
for(int i=0;i<10;i++){
Thread.sleep(1000);
publishProgress(null);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
return null;
}
@Override
protected void onPostExecute(Void result) {
tv.setText("完成");
super.onPostExecute(result);
}
}
}
AsyncTask的参数以及使用方法：一个完整的asyncTask需要经历三次传递参数。第一次传参，execute（）启动时传递给doInBackground（），如需要复制哪个文件，数据上传至哪个服务器等；第二次传参，是doInBackground（）在调用 publishProgress（）时传递给onProgressUpdate（）如：目前的下载进度，已经下载到服务器的列表；第三次传参，是doInBackground（）在运行完以后传递参数给onPostExecute（），如数据获取是否成功。
AsyncTask定义了三种泛型类型参数分别是Params，Progress和Result，即AsyncTask<Params,Progress,Result>;Params是启动任务执行的参数，比如Http的请求URL；Progress后台执行的百分比；Result后台执行的任务最终返回的结果，比如String，下面以一个demo来说明
效果图如下
demo代码如下
package com.example.asynctaskparams;
import android.app.Activity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private MyTask task;
private Button btnStart,btnClose;
private TextView txtContext;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btnStart=(Button)findViewById(R.id.btnStart);
btnClose=(Button)findViewById(R.id.btnClose);
txtContext=(TextView)findViewById(R.id.txtContext);
btnStart.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
task=new MyTask();
//Task发送第一个Task的参数
task.execute(15);
}
});
btnClose.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
task.cancel(true);
task=null;
txtContext.setText("Close");
}
});
}
@Override
protected void onDestroy() {
if(task!=null){
task.cancel(true);
}
super.onDestroy();
}
class MyTask extends AsyncTask<Integer, Integer, Boolean>{
@Override
protected void onPreExecute() {
txtContext.setText("开始");
super.onPreExecute();
}
@Override
protected void onProgressUpdate(Integer... values) {
//Task在此方法体中使用第二个参数
txtContext.setText(""+values[0]);
super.onProgressUpdate(values);
}
@Override
protected Boolean doInBackground(Integer... params) {
//Task使用第一个参数
for(int i=0;i<params[0];i++){
//Task发送第二个参数
publishProgress(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//Task发送第三个参数
return true;
}
@Override
protected void onPostExecute(Boolean result) {
//Task使用第三个参数
txtContext.setText(""+result);
super.onPostExecute(result);
}
}
}