Android AsyncTask 初探

因为在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。在单线程模型中始终要记住两条法则： 

1. 不要阻塞UI线程 
2. 确保只在UI线程中访问Android UI工具包 

（当一个程序第一次启动时，Android会同时启动一个对应的主线程(Main Thread)，主线程主要负责处理与UI相关的事件，如：用户的按键事件，用户接触屏幕的事件以及屏幕绘图事件，并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线程。）

android提供了几种在其他线程中访问UI线程的方法。 
Activity.runOnUiThread( Runnable ) 
View.post( Runnable ) 
View.postDelayed( Runnable, long ) 
Hanlder

（在之前的《线程与消息处理》中我们学习了线程和Handler消息处理机制，如果有计算量比较大的任务，可以创建一个新线程执行计算工作，但是子线程无法更新UI界面，所以通过Handler消息处理机制与UI线程通信，更新UI界面。）

但是有一个问题需要注意，创建的子线程太多时，会影响系统性能。而且，Hanlder这种方式对于整个过程的控制比较精细，但也是有缺点的，例如代码相对臃肿，在多个任务同时执行时，不易对线程进行精确的控制。针对这个问题，Android为我们提供了代替使用Thread和Handler的方案，这就是AsyncTask。它使创建需要与用户界面交互的长时间运行的任务变得更简单。

下面我们来直接认识AsyncTask ：

先来看看AsyncTask的定义：

public abstract class AsyncTask<Params, Progress, Result> 三种泛型类型分别代表“启动任务执行的输入参数”、“后台任务执行的进度”、“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。

一个异步任务的执行一般包括以下几个步骤：

1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。

2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。

3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。

4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。

5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。

使用AsyncTask类，遵守的准则：

1. Task的实例必须在UI thread中创建；
2. Execute（）方法必须在UI thread中调用；
3. 不要手动的调用onPfreexecute()，onPostExecute(result)Doinbackground(params…),onProgressupdate(progress…)这几个方法；
4. 该task只能被执行一次，否则多次调用时将会出现异常;
5. 不能在doInBackground(Params... params)中更改UI组件的信息。

 

通过看源码，发现AsyncTask实际上就是一个线程池，而网上的说法是AsyncTask比handler要轻量级，显然上不准确的，只能这样说，AsyncTask在代码上比handler要轻量级别，而实际上要比handler更耗资源，因为AsyncTask底层是一个线程池！而Handler仅仅就是发送了一个消息队列，连线程都没有开。
但是，如果异步任务的数据特别庞大，AsyncTask这种线程池结构的优势就体现出来了。

下面我们用一个简单的例子来体验一下：

布局文件：

 

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
    <TextView  
        android:layout_width="fill_parent"  
        android:layout_height="200dp"  
        android:id="@+id/textView"  
        android:textSize="20dp"  
        android:gravity="center" />
    <Button  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:id="@+id/button"  
        android:layout_gravity="center"  
        android:textSize="20dp"  
        android:text="启动AsyncTask"  />
    <ProgressBar   
        android:id="@+id/progress_bar"   
        android:layout_width="match_parent"   
        android:layout_height="wrap_content"   
        android:progress="0"  
        android:max="9"  
        style="@android:style/Widget.ProgressBar.Horizontal"/> 

</LinearLayout>

 

在MainActivity中实现代码：

public class MainActivity extends Activity {
    private static final String TAG = "topcsa";
    TextView textView; 
    Button button;
    private ProgressBar progressBar;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
         textView = (TextView)findViewById(R.id.textView);  
            button = (Button)findViewById(R.id.button);  
            progressBar = (ProgressBar) findViewById(R.id.progress_bar);
            button.setOnClickListener(new View.OnClickListener(){  
           
                @Override  
                public void onClick(View v) {  
                    // TODO Auto-generated method stub  
                    MyAsyncTask asyncTask = new MyAsyncTask();  
                    asyncTask.execute(1000);  
                }  
            }); 
        
    }
    
    
    class MyAsyncTask extends AsyncTask<Integer, Integer, String>  
       {  
        @Override  
            protected void onPreExecute() {  
                // TODO Auto-generated method stub  
                super.onPreExecute();  
                Log.d(TAG, "onPreExecute");  
            }

        @Override
        protected String doInBackground(Integer... params) {
            // TODO Auto-generated method stub
            Log.d(TAG, "doInBackground");  
            for(int i = 0; i < 10; i++)  
            {  
                publishProgress(i);  
                try {  
                    Thread.sleep(params[0]);  
                }catch(InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
            Log.d(TAG, "Background work over");  
            return "Background work over."; 
        }  
        @Override  
        protected void onProgressUpdate(Integer... values) {  
            // TODO Auto-generated method stub  
            super.onProgressUpdate(values);  
            Log.d(TAG, "onProgressUpdate"); 
            progressBar.setProgress(values[0]);
            textView.setText(Integer.toString(values[0]));  
        }
        
        @Override  
        protected void onPostExecute(String result) {  
            // TODO Auto-generated method stub  
            super.onPostExecute(result);  
            Log.d(TAG, "onPostExecute, result = " + result);  
        }
            
       } 

运行程序时，做好与日志输出信息对照查看，有助于更好地理解AsyncTask的运作。

 

下面我们结合java.io.File类完成一个手机文件浏览器：

默认布局文件：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" 
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <ListView
        android:id="@+id/list" 
        android:layout_width="fill_parent"
        android:layout_height="wrap_content" />
</LinearLayout>

子布局文件file_list.xml:

<?xml version="1.0" encoding="utf-8"?>
<TableLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" 
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <TableRow>
        <ImageView
            android:id="@+id/img"
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" />
        <TextView
            android:id="@+id/name"
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" />
    </TableRow>
</TableLayout>

默认的.java文件：

public class MyAsyncTaskListFileDemo extends Activity {
    private List<Map<String,Object>> allFileItems = new ArrayList<Map<String,Object>>() ;
    private SimpleAdapter simple = null ;
    private ListView list = null ;
    private ListFileThread ft = null ;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        super.setContentView(R.layout.main);
        this.list = (ListView) super.findViewById(R.id.list) ;
        File filePath = new File(java.io.File.separator); // 从根目录下开始列出
        this.list.setOnItemClickListener(new OnItemClickListenerImpl()) ;
        this.ft = new ListFileThread() ;
        this.ft.execute(filePath) ;
    }
    
    private class OnItemClickListenerImpl implements OnItemClickListener{

        @Override
        public void onItemClick(AdapterView<?> parent, View view, int position,
                long id) {
            File currFile = (File) MyAsyncTaskListFileDemo.this.allFileItems
                    .get(position).get("name");
            if (currFile.isDirectory()) { // 当前是一个目录
                MyAsyncTaskListFileDemo.this.allFileItems = new ArrayList<Map<String,Object>>() ;
                MyAsyncTaskListFileDemo.this.ft = new ListFileThread() ;
                MyAsyncTaskListFileDemo.this.ft.execute(currFile) ;
            }
        }
        
    }
    
    private class ListFileThread extends AsyncTask<File, File, String> {
        
        @Override
        protected void onProgressUpdate(File... values) {
            Map<String,Object> fileItem = new HashMap<String,Object>() ;    // 表示可以返回
            if (values[0].isDirectory()) {
                fileItem.put("img", R.drawable.folder_close); // 文件夹
            } else {    // 是文件
                fileItem.put("img",R.drawable.file) ;
            }
            fileItem.put("name", values[0]) ;
            MyAsyncTaskListFileDemo.this.allFileItems.add(fileItem) ;
            MyAsyncTaskListFileDemo.this.simple = new SimpleAdapter(
                    MyAsyncTaskListFileDemo.this,
                    MyAsyncTaskListFileDemo.this.allFileItems,
                    R.layout.file_list, new String[] { "img", "name" },
                    new int[] { R.id.img, R.id.name });
            MyAsyncTaskListFileDemo.this.list
                    .setAdapter(MyAsyncTaskListFileDemo.this.simple);
        }

        @Override
        protected String doInBackground(File... params) {
            if (!params[0].getPath().equals(java.io.File.separator)) { // 不是根目录
                Map<String,Object> fileItem = new HashMap<String,Object>() ;    // 表示可以返回
                fileItem.put("img",R.drawable.folder_open) ;    // 可以返回
                fileItem.put("name", params[0].getParentFile()) ;
                MyAsyncTaskListFileDemo.this.allFileItems.add(fileItem) ;
            }
            if (params[0].isDirectory()) {    // 是文件夹
                File tempFile [] = params[0].listFiles() ;
                if(tempFile != null) {
                    for (int x = 0; x < tempFile.length; x++) {
                        this.publishProgress(tempFile[x]) ;
                    }
                }
            }
            return "文件已列出";
        }
    }
}

运行程序即可。

 

当然，AsyncTask也不是完全的完美。下面加个有关AsyncTask不足的文章：

http://www.oschina.net/question/54100_27825