Android之Handler类

人的缺点就像花园里的杂草，如果不及时清理，很快就会占领整座花园。

本讲内容：Handler类

Anroid的UI是线程不安全的，所以如果想要更新应用程序里的UI元素，则必须在主线程中进行，否则就会出现异常。

一、Handler的介绍

1、Handler是什么？

handler是android给我们提供用来更新UI的一套机制，也是一套消息处理的机制，可以用于发送和处理消息。

2、Handler的作用？

Android在设计的时候，就封装了一套消息创建、传递、处理机制，如果不遵循这样的机制就没有办法更新UI信息的，就会抛出异常信息。

二、android为什么要设计只能通过Handler机制更新UI呢？

最根本的目的是解决多线程并发问题。假设如果在一个Activity当中，有多个线程去更新UI，并且都没有加锁机制，将会产生更新界面错乱。如果对更新UI的操作都进行加锁处理的话又会产生性能下降。处于对以上问题的考虑，android给我们提供了一套更新UI的机制，我们只需遵循这样的机制就可以了，根本不用去考虑多线各问题，所有的更新UI的操作，都是在主线程的消息队列当中轮询处理。

三、解析异步消息处理机制原理

Android中的异步消息处理主要由四个部分组成，Message、Handler、MessageQueue和Looper。

1、Message

Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间交换数据。

2、Handler

Handler是处理者的意思，它主要是用于发送和处理消息的，发送消息一般是使用Handler的sendMessage()方法，而发出的消息经过一系列处理后，最终会传递到Handler的handleMessage()方法中。

3、MessageQueue

MessageQueue是消息队列的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程中只会有一个MessageQueue对象。（MessageQueue对象不需要我们自己创建）

4、Looper

Looper是每个线程中的MessageQueue的管家，调用Looper的loop()方法后，就会进入到一个无限循环当中，然后每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handleMessage()方法中。每个线程也只会有一个Looper对象。除了主线程有默认的Looper对象，其它线程默认是没有Looper对象。如果想让我们新创建的线程拥有Looper对象时，我们首先应调用Looper.prepare（）方法来创建消息队列，然后再调用Looper.loop（）方法进入消息循环。

注意：Looper.myLooper()：获取当前进程的looper对象，类似的 Looper.getMainLooper() 用于获取主线程的Looper对象。

异步消息处理的整个流程：

首先在主线程当中创建一个Handler对象，并重写handleMessage()方法，然后当子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler将这条消息发出去。之后这条消息会被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出待处理的消息，最后分发回Handler的handleMessage()方法中。由于Handler是在主线程中创建的，所以此时handleMessage()方法中的代码也会在主线程中运行，于是我们在这里就可以放心地进行UI操作了。

总结：handler负责发送消息，Looper负责接收Handler发送的消息，并直接把消息回传给handler自己，MessageQueue就是一个存储消息的容器

了解：我们默认整个程序都是通过ActivityThread创建所有的Activity并回调整个Activity的各种方法。ActivityThread默认为每个Activity创建一个线程叫main线程，包括一个Looper和一个Message对象。ThreadLocal类主要在一个线程当中保存一些变量的信息（通过set()、get()方法）。

四、HandlerThread解决多线程并发问题（示例九）

HandlerThread 与Thread的区别：

HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，它有个Looper成员变量。并可以指定创建的Thread的id。

示例一：在子线程中更新UI会出现异常（如：点击按钮改变TextView文字）

  

下面是res/menu/main.xml 文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >
    
    <Button 
        android:id="@+id/change_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Change Text"/>
    
    <TextView 
        android:id="@+id/text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text="Hello world"
        android:textSize="25sp"/>

</RelativeLayout>

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity {
	private TextView text;
	private Button changeText;

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		text=(TextView) findViewById(R.id.text);
		changeText=(Button) findViewById(R.id.change_text);
		changeText.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				new Thread(new Runnable() {//使用匿名类
					public void run() {
						text.setText("Nice to meet you");//在子线程中更新UI
					}
				}).start();
			}
		});
	}
}

示例二：解决在线程中进行UI操作

但是有些时候，我们必须在子线程里去执行一些耗时任务，然后根据任务的执行结果来更新相应的UI控件，对于这种情况，Android提供了一套异步消息处理机制，完美地解决了在子线程中进行UI操作的问题。

这时有两种方法可以达到目的。：

一种是handler.sendMessage。发一个消息，再根据消息，执行相关任务代码。

另一种是handler.post(r)。r是要执行的任务代码。意思就是说r的代码实际是在UI线程执行的。可以写更新UI的代码

  

下面是MainActivity.java主界面文件：（方法一）

public class MainActivity extends Activity {
	private TextView text;
	private Button changeText;
	
	public static final int UPDATE_TEXT=1;
	
	private Handler handler=new Handler(){
		public void handleMessage(android.os.Message msg) {//handleMessage()接收sendMessage()方法发送的消息
			switch (msg.what) {
			case UPDATE_TEXT:
				//在这里进行UI操作
				text.setText("Nice to meet you");
				break;
			}
		}
	};

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		text=(TextView) findViewById(R.id.text);
		changeText=(Button) findViewById(R.id.change_text);
		changeText.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				new Thread(new Runnable() {//使用匿名类
					public void run() {
						Message msg=new Message();
						msg.what=UPDATE_TEXT;
						handler.sendMessage(msg);
					}
				}).start();
			}
		});
	}
}

下面是MainActivity.java主界面文件：（方法二）

public class MainActivity extends Activity {
	private TextView text;
	private Button changeText;
	
	private Handler handler=new Handler();

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		text=(TextView) findViewById(R.id.text);
		changeText=(Button) findViewById(R.id.change_text);
		changeText.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				new Thread(new Runnable() {
					public void run() {
						handler.post(new Runnable() {
							public void run() {
								//在这里进行UI操作  
								text.setText("Nice to meet you");  
							}
						});
					}
				}).start();
			}
		});
	}

}

示例三：图片变换

Handler.postDelayed(Runnable r, long delayMillis)方法的使用:

延时delayMillis毫秒 将Runnable插入消息列队，Runnable将在handle绑定的线程中运行。post 是立即插入消息列队，当消息列队处理到该消息时才运行。只执行一次而不是每delayMillis 执行一次

    

下面是res/menu/main.xml 文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:background="#555486"
        android:gravity="center"
        android:text="图片变换"
        android:textColor="#fff"
        android:textSize="25sp" />

    <ImageView
        android:id="@+id/id_image"
        android:layout_width="300dp"
        android:layout_height="300dp"
        android:layout_centerInParent="true"
        android:src="@drawable/res1" />

</RelativeLayout>

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity {
	private ImageView image;
	private int images[]={R.drawable.res1,R.drawable.res2,R.drawable.res3};
	private int index;
	
	private Handler handler=new Handler();
	private MyImageChange change=new MyImageChange();

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		image=(ImageView) findViewById(R.id.id_image);
		handler.postDelayed(change, 1000);//相当于后二行
//		Thread a=new Thread(change);
//		a.start();
	}
	
	class MyImageChange implements Runnable{
		public void run() {
			index++;
			index=index%3;//图片不断循环
			image.setImageResource(images[index]);
			handler.postDelayed(change, 1000);
		}
	}

}

示例四：handler.sendMessage(message)方法及arg1、arg2两个整型参数的使用

   

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity {
	private TextView text;
	private Button changeText;
	
	private Handler handler=new Handler(){
		//handleMessage()接收sendMessage()方法发送的消息  
		public void handleMessage(android.os.Message msg) {
			text.setText(""+msg.arg1+"-"+msg.arg2);//注意把""+使转化成字符串
		}
	};

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text=(TextView) findViewById(R.id.text);
        changeText=(Button) findViewById(R.id.change_text);
        changeText.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				new Thread(new Runnable() {
					public void run() {
						Message message=new Message();
						message.arg1=88;//arg1、arg2参数是整型的int
						message.arg2=99;
						handler.sendMessage(message);
					}
				}).start();
			}
		});
    }

}

示例五：obj参数(参数比较多时)、handler.obtainMessage()方法、message.sendToTarget()方法

  

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity {
	private TextView text;
	private Button changeText;
	
	private Handler handler=new Handler(){
		//handleMessage()接收sendMessage()方法发送的消息  
		public void handleMessage(android.os.Message msg) {
			text.setText(""+msg.obj);
		}
	};

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text=(TextView) findViewById(R.id.text);
        changeText=(Button) findViewById(R.id.change_text);
        changeText.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				new Thread(new Runnable() {
					public void run() {
			//handler.obtainMessage()与new Message()区别是：obtainMessage()是从消息池拿来的一个msg，不必另开空间new。
						Message message=handler.obtainMessage();
						//Message message=new Message();
						Person person=new Person();
						person.age=22;
						person.name="jin";
						message.obj=person;//指定一个obj对象
			//message.sendToTarget()与handler.sendMessage(message)本质上一样的，没什么区别。		
						message.sendToTarget();
						//handler.sendMessage(message);
					}
				}).start();
			}
		});
    }
    
    class Person{
    	private int age;
    	private String name;
    	public String toString() {
    		return "name="+name+" age="+age;
    	}
    }

}

示例六：移除一个消息对象

下面是res/menu/main.xml 文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:background="#555486"
        android:gravity="center"
        android:text="图片变换"
        android:textColor="#fff"
        android:textSize="25sp" />

    <ImageView
        android:id="@+id/id_image"
        android:layout_width="300dp"
        android:layout_height="300dp"
        android:layout_centerInParent="true"
        android:src="@drawable/res1" />
    
    <Button 
        android:id="@+id/id_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_centerHorizontal="true"
        android:text="移除一个消息对象"
        android:layout_marginBottom="10dp"/>

</RelativeLayout>

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity implements OnClickListener{
	private Button b;
	private ImageView image;
	private int images[]={R.drawable.res1,R.drawable.res2,R.drawable.res3};
	private int index;
	
	private Handler handler=new Handler();
	private MyImageChange change=new MyImageChange();

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		b=(Button) findViewById(R.id.id_button);
		b.setOnClickListener(this);
		image=(ImageView) findViewById(R.id.id_image);
		handler.postDelayed(change, 1000);//相当于后二行
	}
	
	class MyImageChange implements Runnable{
		public void run() {
			index++;
			index=index%3;//图片不断循环
			image.setImageResource(images[index]);
			handler.postDelayed(change, 1000);
		}
	}

	/**
	 * 移除一个消息对象
	 */
	public void onClick(View v) {
		handler.removeCallbacks(change);
	}

}

示例七：new Callback()截获信息，使终止

下面是res/menu/main.xml 文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:background="#555486"
        android:gravity="center"
        android:text="截获信息"
        android:textColor="#fff"
        android:textSize="25sp" />

    <Button
        android:id="@+id/id_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text="截获信息" />

</RelativeLayout>

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity implements OnClickListener{
	private Button b;
	
	private Handler handler=new Handler(new Callback() {
		public boolean handleMessage(Message msg) {
			Toast.makeText(MainActivity.this, "1", Toast.LENGTH_LONG).show();
			return true;//true 拦截消息使下面handleMessage()不被执行
		}
	}){
		public void handleMessage(Message msg) {
			Toast.makeText(MainActivity.this, "2", Toast.LENGTH_LONG).show();
		}
	};
	
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		b=(Button) findViewById(R.id.id_button);
		b.setOnClickListener(this);
	}

	public void onClick(View v) {
		handler.sendEmptyMessage(10);//发送一个空消息
	}

}

示例八：自定义线程

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity {
	private MyThread myThread;
	
	private Handler handler=new Handler(){
		public void handleMessage(Message msg) {
			Log.d("MainActivity", "UI(主)线程-------"+Thread.currentThread());
		};
	};
	
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		myThread=new MyThread();
		myThread.start();
		try {
			Thread.sleep(1000);
		} catch (Exception e) {
			e.printStackTrace();
		}
		myThread.hander.sendEmptyMessage(1);//给myThread发送一个消息
		handler.sendEmptyMessage(1);//给主线程发送一个消息
	}
	
	class MyThread extends Thread{
		public Handler hander;//与当前子线程关联，必须创建与其关联的Looper对象，否则报错
		public void run() {
			Looper.prepare();//创建一个Looper对象
			hander=new Handler(){
				public void handleMessage(Message msg) {
					Log.d("MainActivity", "当前线程："+Thread.currentThread());
				}
			};
			Looper.loop();//让Looper开始工作，从消息队列里取消息，处理消息。循环处理消息
   //注意：写在Looper.loop()之后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，
   //loop才会中止，其后的代码才能得以运行。 
		}
	}

}

运行程序打印：

示例九：HandlerThread解决多线程并发问题

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity {
	private HandlerThread myThread;
	private Handler handler;
	
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		myThread=new HandlerThread("thread01");//创建一个线程并指定名称
		myThread.start();
		
		//如果使用普通Thread，myThread.getLooper()会出现空指针异常。因为当主线程写入时，而myThread未来得及创建
		handler=new Handler(myThread.getLooper()){
			//获得ymThread线程的Looper对象，使handleMessage()方法在ymThread线程执行，可以在这执行耗时操作
			public void handleMessage(Message msg) {
				Log.d("MainActivity", "当前线程----------》"+Thread.currentThread());
			}
		};
		handler.sendEmptyMessage(1);
	}

}

运行程序打印：

示例十：主线程与子线程之间的通讯

下面是MainActivity.java主界面文件：

public class MainActivity extends Activity implements OnClickListener{
	private Button send;
	
	private Handler myThreadHandler;//子线程的handler
	
	//创建主线程的Handler
	private Handler handler=new Handler(){
		public void handleMessage(android.os.Message msg) {
			//1秒后给子线程发送一个消息
			Message message=new Message();
			myThreadHandler.sendMessageDelayed(message, 1000);
			Log.d("MainActivity", "main Thread");
		};
	};
	
	
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		send=(Button) findViewById(R.id.id_send);
		send.setOnClickListener(this);
		
		//创建一个子线程
		HandlerThread myThread=new HandlerThread("thread01");
		myThread.start();
		
		//创建子线程的Handler
		myThreadHandler=new Handler(myThread.getLooper()){
			public void handleMessage(Message msg) {
				//1秒后给主线程发送一个消息
				Message message=new Message();
				handler.sendMessageDelayed(message, 1000);
				Log.d("MainActivity", "myThread Thread");
			}
		};
	}

	public void onClick(View v) {
		switch (v.getId()) {
		case R.id.id_send:
			handler.sendEmptyMessage(1);
			break;
		}
	}

}

运行程序打印：循环打印

Take your time and enjoy it 要原码的、路过的、学习过的请留个言，顶个呗～～