IntentService,(Looper,Message,Handler)三者之间的关系，AsyncTask，
IntentService
IntentService与service的最大的区别就是IntentService可以进行耗时操作，因为它自带了一个线程，记住只有一个线程。
在IntentService中有一个队列的概念，即在第一次启动IntentService，并在onHandleIntent中执行的时候，再第二次次启动IntentService，第二次的操作不会立刻执行，而是先将其放在队列中，当第一次运行完时，再执行第二次操作。这与Service是不一样的，当第一次还未执行完时，启动第二次，他会直接从onStartCommand开始执行。而不是像第一次一样按循序执行。
IntentService的建立循序：
1）新建的类会继承IntentSrevice。
2）重写onHandleIntent（）方法。许多操作基本上都是在这个方法中写的。
3）在Activity中像执行Service一样去启动IntentService。
4)记住，一定要注册：
<service android:name=".myIntentSrevice"/>代码如下：
public class myIntentSrevice extends IntentService {
int count;
/** * Creates an IntentService. Invoked by your subclass's constructor. * * @param name Used to name the worker thread, important only for debugging. */
public myIntentSrevice(String name) {
super(name);
}
//必须写这个才能注册
public myIntentSrevice() {
this("");
}
@Override
protected void onHandleIntent(Intent intent) {
while (count<100){
if(count==99){
count=0;
}
count++;
Intent intent2 =new Intent("com.pp");
// intent.setAction("com.pp");
intent2.putExtra("count",count);
sendBroadcast(intent2);//在线程中启动广播
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void onDestroy() {
Log.d("","结束service");
super.onDestroy();
}
}
在Activity中：
Intent intent3= new Intent(getApplicationContext(),myIntentSrevice.class);
startService(intent3);
Looper,Message,Handler三者之间的关系
线程与进程
在android中一个应用就是一个进程，在一个进程中可以有多个线程。
其中最重要的一个线程是UI主线程，他就像我们看电影一样在界面中不停的画view。UI主线程是不允许其他线程修改UI的View的。当必须由子线程修改view时，就可以用Looper,Message,Handler三者之间的关系之间的关系来解决。也可以用AsyncTask，这个等会再说。
其图如下;
在主线程中建立一个Handler并复写方法handleMessage（）（大多数操作都在这里）接受消息，在子线程中用主线程建立的Handler对象发送message消息。
记住在主线程建立Handler对象后就形成了一个MessageQueue——Looper机制。当子线程发送消息给主线程，这个消息会放在MessageQueue中。当主线程运行到MessageQueue时会将数据取走。
下面我们写一个倒计时的例子：
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case DESC:
button_desc.setText((String) msg.obj);
break;
}
}
} ;
case R.id.button_desc:
new Thread(new Runnable() {
@Override
public void run() {
while (count>0){
count--;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// Message message =new Message();
Message message= handler.obtainMessage(); //它会获得一个用过的message对象，没有的话会自动建立。
message.obj=count+"秒";//赋予要传递的数据
message.what=DESC;//这类消息的标示。
handler.sendMessage(message);
}
}
}).start();
break;
在按键的点击事件中：
// Message message =new Message();
Message message= handler.obtainMessage(); //它会获得一个用过的message对象，没有的话会自动建立。
message.obj=count+"秒";//赋予要传递的数据
message.what=DESC;//这类消息的标示。
handler.sendMessage(message);//发送这个消息第二种写法：
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case DESC:
count--;
button_desc.setText(count+"秒");
if(count>0){
try {
Thread.sleep(1000);
handler.sendEmptyMessage(DESC);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
}
} ;
case R.id.button_desc:
handler.sendEmptyMessage(DESC);//再次发送一个空消息Handler补偿说明：
（1）Handler.post()的用法：可以在子线程中调用handler.post()在post包含的Runnable()的run方法中更新UI。
代码：
new Thread(){
@Override
public void run() {
handler.post(new Runnable() {
@Override
public void run() {
firstEdit.setText("hahahhaha");
}
});
}
}.start();
（2） handler.postDelayed(myRunnable,1000);可以进行定时更新UI操作。
1）建立一个继承自Runnale的类，在run方法中更新Ui。
2）建立这个类的对象，在oncreat（）和继承自Runnale的类的runn（）中调用 handler.postDelayed(myRunnable,1000);这样就可以
定时实现更新UI的操作了。
代码如下：
private MyRunnable myRunnable = new MyRunnable();
class MyRunnable implements Runnable{
@Override
public void run() {
index++;
index = index%3;
imageView.setImageResource(images[index]);
handler.postDelayed(myRunnable,1000);
}
}
在oncreat（）中：
handler.postDelayed(myRunnable,1000);
（3） handler.removeCallbacks(myRunnable);
用于移除Runnable的回调机制。当调用这行代码的时候 handler.postDelayed(myRunnable,1000);中的myRunnable就不起作用了。
（4）Message：Handler可以通过发送message来传递给主线程一些小消息。要发送消息，必须有消息。可以通过两种方式获得Message
：Message message = new Message（）；或者 Message message = handler.obtainMessage();//这个是获得系统的闲置的Message。
如果没有闲置的会自动给你生成一个。
消息载体是： message.arg1 =88;//message.arg1 是int类型的载体。如果想传递字符串或其他的对象可以用message.obj=?//可以是
字符串，各种对象。发送有两种形式： handler.sendMessage(message);//这一种是比较常用的。如果用Message message =
handler.obtainMessage();生成message的话，可以用message.sendToTarget();发送，否则不可以。
发送的消息会在handler的handleMessage（）函数中接收的，一般先判读是否是这个消息。用handler.what或者
handler.arg1/2判断。
代码如下：
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Toast.makeText(getApplicationContext(),""+msg.what,Toast.LENGTH_SHORT).show();
}
};
public void onClick(View view) {
new Thread(new Runnable() {
@Override
public void run() {
Message message = handler.obtainMessage();//如果这样获得message，可以这样发送：
message.sendToTarget();
// 否则不可以这样发送用这个发送：handler.sendMessage(message);。
message.arg1 =88;
message.sendToTarget();
handler.sendMessage(message);
handler.sendEmptyMessage(1);//还可以发空字符串。
}
}).start();
}
});
}(5)在创建handler的时候还可以在构造器中添加Callback()的对象，在这个类中也有一个handleMessage方法，只不过它有返回值。这
是一个拦截机制，在发送过来的消息会先在Callback中处理，如果返回false在这里处理完后会再在handler的handleMessage方法中处
理。如果返回true。则此消息不会再往下传。
Handler Looper MessageQueue三者之间的关系：
一，Handler封装了消息的发送（主要包括消息发送给谁）
Looper
1.内部包含一个消息队列也就是MessageQueue，所有发送的handler发送的消息都走这个消息队列。
2.Looper.Looper方法就是一个死循环，不断的从MessageQueue中取消息，如果有消息就处理消息，如果没有就阻塞。
二.MessageQueue，就是一个消息队列，可以添加消息和处理消息
三.handler内部会跟Looper进行关联，也就是说在handler的内部就可以找到Looper，找到了Looper也就找到了MessageQueue，在
Hnadler中发送消息也就是向MessageQueue中发送消息。
总结：Handler负责发送消息，Looper负责接收Handler发送的消息，并把消息回传给Handler自己。MessageQueue就是存储消息的容器
。
HandlerUI主线程给子线程发送消息。
在子线程中建立Handler的对象，在UI主线程中调用这个对象的引用，并发送消息。注意。在子线程中必须自己建立Looper对象： Looper.prepare();//创建Looper对象.并且调用Looper.loop()方法。在这之间初始化Handler的对象，重写handleMessage（）方法
代码如下：
class MyThread extends Thread{
Handler handler;
@Override
public void run() {
Looper.prepare();//创建Looper对象
handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Toast.makeText(getApplicationContext(), ""+msg.what, Toast.LENGTH_SHORT).show();
}
};
// Toast.makeText(getApplicationContext(), "aaaaa", Toast.LENGTH_SHORT).show();
Looper.loop();//实现消息的循环处理
}
}注意：
在UI主线程中thread.start();时不可以立刻发送消息： thread.handler.sendEmptyMessage(1);这样会有空指针的错误，应该延迟一段时间。
Handler绑定Looper
在创建Handler对象的时候可以不用默认的Looper对象是可以绑定你指定的某个线程的Looper对象。例如：
handler = new Handler(thread.getLooper())这就是绑定了threadThread的Looper对象，当handler与某个线程的Looper对象绑定时
handleMessage（）方法就会在这个线程中执行而不是Handler所在的对象执行。
但是如果随便的绑定一个线程的Looper对象的话，可能会由于线程的不同步等问题会有空指针的问题出现（在绑定这个线程的Looper的时候可能还没有创建成功），为了避免这种问题的发生，google开发了一种HandlerThread的线程，这个线程就有Looper对象在我们调用thread.getLooper()的时候会先判断Looper是否为空，如果为空就等待，当Looper创建成功的时候会通知它，然后再执行。这样就避免了多线程不同步引起的空指针的问题。这样我们也可以在handleMessage（）中执行一些耗时操作了。
用Hnadler机制实现主线程与子线程之间的通信。
建立两个Handler实例，都是在UI中建立的，只不过有一个Handler的实例是绑定的子线程的Looper。这样就可以用这个Handler的实例在子线程中实现接收主线程的消息了。完整如下：
public class MainActivity extends AppCompatActivity {
private TextView firstEdit;
private Button myFirstbutton;
private ImageView imageView;
private Handler threadHandler;
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
threadHandler.sendEmptyMessageDelayed(2,1000);
Log.d("aaaa",""+Thread.currentThread());
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
setContentView(R.layout.activity_main);
firstEdit = (TextView) findViewById(R.id.first_edit);
myFirstbutton = (Button) findViewById(R.id.first_button);
imageView = (ImageView) findViewById(R.id.myImageView);
HandlerThread thread = new HandlerThread("Handler Thread");
thread.start();
threadHandler = new Handler(thread.getLooper()){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
handler.sendEmptyMessageDelayed(1,1000);
Log.d("aaaa",""+Thread.currentThread());
}
};
myFirstbutton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
handler.sendEmptyMessage(1);
}
});
}
}
四种更新UI的方法
方法一：handler.post（new Runnable(){
run(){
}
}）
方法二：
handler.setmaeesge()在handler的handleMessage（）方法中更新UI；
方法三
调用view的post方法。
firstEdit.post(new Runnable() {
@Override
public void run() {
firstEdit.setText("hehelooooooo");
}
});
方法四
调用runOnUiThread（）方法：
runOnUiThread(new Runnable() {
@Override
public void run() {
firstEdit.setText("heheloooooooooo");
}
});
主线程向子线程发送消息
在主线程给子线程发送消息时，子线程的run（）方法的代码的handler的代码必须放在 Looper.prepare();和 Looper.loop();这两行代码之间。但在主线程中建立Handler时，主线程是默认就有的，所以不需要写。
MyThread thread = new MyThread();
thread.start();
与 handler.sendEmptyMessage(0);这两行代码不可以在一起，因为启动线程需要时间而handler.sendEmptyMessage(0)的执行时间很小。所以在线程还没有启动的时候，主线程就已经发送消息了，会造成空指针。
代码如下：
private Handler handler;
class MyThread extends Thread{
@Override
public void run() {
Looper.prepare();
handler =new Handler(){
@Override
public void handleMessage(Message msg) {
Log.d("thread","我收到了");
}
};
Looper.loop();
}
}
//在点击事件中
case R.id.button_desc:
MyThread thread = new MyThread();
thread.start();
case R.id.button_send:
// Message message =handler.obtainMessage();
// handler.sendMessage(message);
handler.sendEmptyMessage(0);
break;AsyncTask
AsyncTask的基本原理与Handler是一样的，就是用Handler进行封装的，只不过
可以在其中的方法中可以对View进行操作，一般是以内部类的形式存在的。
操作顺序如下：
1）写一个类继承于AsyncTask（String,Integer,String）（是尖括号哦）
第一个参数为doInBackground的参数，最后一个是doInBackground的返回值的leixing
第二个参数为onProgressUpdate接受的第一个参数。
doInBackground（）为后台运行过程。onPostExecute(String s)为运行结束时的操作。
onProgressUpdate（）为在运行过程中对view的操作。
onPostExecute（）和onProgressUpdate（）可以对view进行操作。
doInBackground（）的publishProgress(count);为调用onProgressUpdate()方法。
2)在Activity的某个位置建立此类的对象。并调用execute(“”)方法。
写一个下载的例子：
class MyAsyncTask extends AsyncTask<String,Integer,String>{
@Override
protected String doInBackground(String... params) {
while (count<101){
count++;
publishProgress(count);//调用onProgressUpdate（）方法
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return "全部传完了哦";
}
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
down_button.setText(s);
}
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
progressBar.setProgress(values[0]);//在参数不确定的时候values是以数组的形式处理
的
}
}
}
case R.id.down_button:
MyAsyncTask myAsyncTask =new MyAsyncTask();
myAsyncTask.execute("dd");//dd是随便写的。
break;