Android异步任务处理之AsyncTask

首先介绍一下线程的概念
线程有时也被称为轻量级进程，是程序执行的最小单元。
实现线程的两种方式：

-

• 继承Thread类，重写run()方法 ，run()方法里面才是封装线程的代码
  通过调用start()方法启动线程并调用run()方法。

public class MyThread extends Thread
            {
                public void run()
                {
                    for(int x=0; x<100; x++)
                    {
                        System.out.println(getName()+"---"+"hello"+x);
                    }
                }
            }

            public MyThreadTest
            {
                public static void main(String[] args)
                {
                    MyThread my1 = new MyThread();
                    MyThread my2 = new MyThread();

                    my1.start();
                    my2.start();
                }
            }

• 实现Runnable接口
  a:创建一个类实现Runnable接口
  b:重写run()方法
  c:创建实现类对象，并把它作为参数传递给Thread类的构造方法，创建Thread对象
  d:通过Thread的对象执行

public class MyRunnable implements Runnable
            {
                public void run()
                {
                    public void run()
                    {
                        for(int x=0; x<100; x++)
                        {
                            System.out.println(Thread.currentThread().getName()+"---"+"hello"+x);
                        }
                    }
                }
            }

            public class MyRunnableTest
            {
                public static void main(String[] args)
                {
                    MyRunnable my = new MyRunnable();

                    Thread t1 = new Thread(my);
                    Thread t2 = new Thread(my);

                    t1.start();
                    t2.start();
                }
            }

AsyncTask是Android中轻量级的异步操作类，可直接继承Asyntask在类中进行异步操作，并通过提供的接口，反馈当前异步操作的执行进度。

class MyTask extends AsyncTask<String, Float, String> {

        /*
         * (non-Javadoc)
         * 
         * @see android.os.AsyncTask#doInBackground(Params[])
         * 和线程中的run()方法非常相似，执行后台操作
         */
        @Override
        protected String doInBackground(String... arg0) {
            try {
                URL url = new URL(arg0[0]);
                URLConnection connection = url.openConnection();
                InputStream is = connection.getInputStream();
                InputStreamReader isr = new InputStreamReader(is);
                BufferedReader br = new BufferedReader(isr);
                String line;
                StringBuilder builder = new StringBuilder();
                while ((line = br.readLine()) != null) {
                    builder.append(line);
                }
                br.close();
                is.close();
                return builder.toString();
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
        }

        @Override
        protected void onCancelled(String result) {
            super.onCancelled(result);
        }

        /*
         * (non-Javadoc)
         * @see android.os.AsyncTask#onPostExecute(java.lang.Object)
         * 当前的Asyntask执行完后，会调用该方法
         * result即doInBackground返回的值
         */
        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);
        }

        /*
         * (non-Javadoc)
         * @see android.os.AsyncTask#onPreExecute()
         * Asyntask执行之前会执行该方法
         */
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        /*
         * (non-Javadoc)
         * @see android.os.AsyncTask#onProgressUpdate(Progress[])
         * 用于反馈任务执行的进度
         */
        @Override
        protected void onProgressUpdate(Float... values) {
            // TODO Auto-generated method stub
            super.onProgressUpdate(values);
        }
    }

通过.execute()来调用;