Android AsyncTask

package com.ltc.asynctask;

import android.app.Activity;
import android.content.Intent;
import android.os.AsyncTask;
import android.os.Bundle;
import android.widget.ProgressBar;

/**
 * AsyncTask 的优势体现在：<br>
 * •线程的开销较大，如果每个任务都要创建一个线程，那么应用程 序的效率要低很多； <br>
 * •线程无法管理，匿名线程创建并启动后就不受程序的控制了，如果有很多个请求发送，那么就会启动非常多的线程，系统将不堪重负。 <br>
 * •另外，前面已经看到，在新线程中更新UI还必须要引入handler，这让代码看上去非常臃肿。<br>
 * 
 * Task的实例必须在UI thread中创建
 * execute方法必须在UI thread中调用
 * 该task只能被执行一次，否则多次调用时将会出现异常
 * @author LTC
 *
 */
public class ActivityMain extends Activity {
	
	ProgressBar progressBar = null;
	
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        progressBar = (ProgressBar)findViewById(R.id.actmain_proogressbar);
        
        new AsyncTask<Void, Void, Void>(){
        	
        	/**
        	 * 在UI主线程中执行，在doInBackground()之前执行。
        	 * 
        	 */
        	@Override
        	protected void onPreExecute() {
        		// TODO Auto-generated method stub
        		super.onPreExecute();
        	}
        	
        	/**
        	 * 将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。
        	 * 可以调用 publishProgress方法来更新实时的任务进度。
        	 * 该方法是抽象方法，子类必须实现。
        	 */
        	@Override
        	protected Void doInBackground(Void... params) {
        		// TODO Auto-generated method stub
        		
        		int i = 0;
        		while(i <= 100){
        			progressBar.setProgress(i);
        			
        			try {
    					Thread.sleep(25);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
        			
    				if(i == 100){
    					Intent intent = new Intent();
    					intent.setClass(ActivityMain.this, Activity2.class);
    					startActivity(intent);
    				}
    				
        			++i;
        		}
        		
        		return null;
        	}
        	
        	/**
        	 * 在publishProgress方法被调用后，
        	 * UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。
        	 */
        	@Override
        	protected void onProgressUpdate(Void... values) {
        		// TODO Auto-generated method stub
        		super.onProgressUpdate(values);
        	}
        	
        	/**
        	 * 在doInBackground 执行完成后，
        	 * onPostExecute 方法将被UI thread调用，
        	 * 后台的计算结果将通过该方法传递到UI thread.
        	 */
        	@Override
        	protected void onPostExecute(Void result) {
        		// TODO Auto-generated method stub
        		super.onPostExecute(result);
        	}
        	
        	@Override
        	protected void onCancelled() {
        		// TODO Auto-generated method stub
        		super.onCancelled();
        	}
        }.execute();
    }
}

1. AsyncTask于Thread的比较

2. AsyncTask如何实现

3. AsyncTask如何使用，Activity/Service都适用吗？

4. 如何终止AsyncTask

5.线程池

JDK1.5中线程池的实现

 ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
 long keepAliveTime, TimeUnit unit,
 BlockingQueue<Runnable> workQueue,
 RejectedExecutionHandler handler)

corePoolSize： 线程池维护线程的最少数量 
maximumPoolSize：线程池维护线程的最大数量 
keepAliveTime： 线程池维护线程所允许的空闲时间
unit： 线程池维护线程所允许的空闲时间的单位
workQueue： 线程池所使用的缓冲队列 
handler： 线程池对拒绝任务的处理策略 

一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。当一个任务通过execute(Runnable)方法欲添加到线程池时：

如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

也就是：处理任务的优先级为：
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。
当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。