Android中多线程的用法

上文讲到：

Handler会向MessageQueue以两种方式发送消息：sendMessage 和post 。他们都会加在消息队列中

他们的区别是：

SendMessage

Handler对象使用Post发送的是一个runnable对象，加在自己的线程队列中进行处理。所以他们还是在一个线程中进行处理。

package com.example.handler02;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu;
import android.view.MenuItem;

public class Handler02 extends Activity {
	
	
	private Handler handler = new Handler();
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_handler02);	
		
		handler.post(r);	 // 使用post发送消息	
		
		System.out.println("Activity  --->"+Thread.currentThread().getId());
		System.out.println("Activity  --->"+Thread.currentThread().getName());
		
		
	}
	
	Runnable r = new Runnable(){

		@Override
		public void run() {
			System.out.println("handler ---> "+Thread.currentThread().getId());
			System.out.println("handler name ---> "+Thread.currentThread().getName());
			
			try{
				Thread.sleep(10000);
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
			
			
		}
		
	};	
}


//通过实验可发现，直接使用handler，将线程类(r)放入到线程队列中时，与Activity是同一个线程，并没有新的线程产生
/*
 * 11-17 11:59:45.130: I/System.out(1555): Activity  --->1
11-17 11:59:45.134: I/System.out(1555): Activity  --->main
11-17 11:59:45.162: I/System.out(1555): handler ---> 1
11-17 11:59:45.162: I/System.out(1555): handler name ---> main
 */

第二种方式：

使用HandlerThread建立一个新的线程对象，并放入到Message Queue中进行处理。

最后发送的是一个message对象，会被handler的handleMessage的函数进行处理，会在被发送到的线程中进行处理。

package com.example.handler03;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.view.Menu;
import android.view.MenuItem;

public class Handler03 extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_handler03);
		
		System.out.println(Thread.currentThread().getId());
		System.out.println(Thread.currentThread().getName());
		
		// 声明一个handler线程，这里HandlerThread 建立了一个新的线程
		HandlerThread handlerThread =new HandlerThread("handler_thread");		
		handlerThread.start(); // 启动线程。
		// 将handler线程绑定到一个消息队列上。
		MyHandler myhandler = new MyHandler(handlerThread.getLooper());// 得到handleThread的线程管理器looper
		Message msg=myhandler.obtainMessage();
		
		Bundle b= new Bundle();
		b.putInt("age", 123);
		b.putString("name", "zhangsan");
		
		
		
		msg.setData(b);
		msg.sendToTarget();  // 将msg发送到目标对象，所谓的目标对象就是生成该对象的handler对象(handlerThread)
		
		
		
		
	}
	// MyHandler是一个继承Handler的类，使用构造函数将Looper(Message Queue管理器)将最新的线程放入线程队列
	// 复写HandleMessage处理线程信息
	class MyHandler extends Handler{
		public MyHandler(){
			
		}
		public MyHandler(Looper looper)  // 需要重写构造函数，将Looper对象放入父类handler的构造函数中，即将hanlder绑定到looper对象的线程上，处理消息队列中的消息
		{                                 // looper是消息对象
			super(looper);
		}
		@Override
		public void handleMessage(Message msg) {
			System.out.println(Thread.currentThread().getId());
			System.out.println(Thread.currentThread().getName());
			System.out.println("handlerMessage");
			
			
			Bundle b= msg.getData();
			int age = b.getInt("age");
			String name=b.getString("name");
			
			System.out.println(name+"");
		}
		
	}	
}
/*
11-17 13:17:41.710: I/System.out(3389): 1
11-17 13:17:41.714: I/System.out(3389): main
11-17 13:17:41.742: I/System.out(3389): 146
11-17 13:17:41.742: I/System.out(3389): handler_thread
11-17 13:17:41.746: I/System.out(3389): handlerMessage
11-17 13:17:41.750: I/System.out(3389): zhangsan

 * 
 * 
 * 
 * */

第三种方法：

使用Java中标准Thread方式：

package com.example.handler02;

import android.app.Activity;
import android.os.Bundle;

public class Handler02_2 extends Activity{
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_handler02);
		
		
		Thread t = new Thread(thread);
		t.start();  // 必须启动线程之后程序才可在新线程中使用
		System.out.println("Activity  --->"+Thread.currentThread().getId());
		System.out.println("Activity  --->"+Thread.currentThread().getName());
		
		
	}
	Runnable thread =new Runnable(){

		@Override
		public void run() {
			System.out.println("handler  ---> "+ Thread.currentThread().getId());
			System.out.println("handler  --->"+ Thread.currentThread().getName());
			
			try{
				Thread.sleep(10000);
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
			
		}
		
	};

}
/*
 
11-17 12:18:27.746: I/System.out(1914): Activity  --->1
11-17 12:18:27.746: I/System.out(1914): Activity  --->main
11-17 12:18:27.762: I/System.out(1914): handler  ---> 101
11-17 12:18:27.762: I/System.out(1914): handler  --->Thread-101  
*/

// 通过实验结果可发现，使用Thread启动了一个新的线程，