AsyncTask

一.什么是AsyncTask？
AsyncTask是一个轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和结果传递给主线程并在主线程中更新UI。
二.如何使用AsyncTask？
来一段平常简单使用AsyncTask来异步操作UI线程的情况，首先新建一个类继承AsyncTask，构造函数传入我们要操作的组件（ProgressBar和TextView）

class MAsyncTask extends AsyncTask<Void, Integer, String>{
        private ProgressBar mProgressBar;
        private TextView mTextView;

        public MAsyncTask(ProgressBar mProgressBar, TextView mTextView) {
            this.mProgressBar = mProgressBar;
            this.mTextView = mTextView;
        }

        @Override
        protected void onPreExecute() {
            mTextView.setText("开始执行");
            super.onPreExecute();
        }

        @Override
        protected String doInBackground(Void... params) {
            for(int i = 0; i <= 10; i++){
                publishProgress(i);//此行代码对应下面onProgressUpdate方法
                try {
                    Thread.sleep(1000);//耗时操作，如网络请求
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return "执行完毕";
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            mProgressBar.setProgress(values[0]);
            super.onProgressUpdate(values);
        }

        @Override
        protected void onPostExecute(String s) {
            mTextView.setText(s);
            super.onPostExecute(s);
        }
    }

在Activity中创建我们新建的MAsyncTask实例并且执行(无关代码省略)：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        MAsyncTask asyncTask = new MAsyncTask(mTestPB, mTestTV);
        asyncTask.execute();//开始执行
        ...
    }
}

三.如何使用 AsyncTask做倒计时？

Activity中代码：

package com.example.administrator.myapp;

import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ProgressBar;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {
    private TextView zimu;
    private Button btn;
    private EditText sr;
    private int time;

private ProgressBar progressBar;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bind();
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                time = Integer.parseInt(sr.getText().toString());
                new MyTask().execute(time);
            }
        });
    }

    private void bind() {
        zimu = findViewById(R.id.zimu);
        btn = findViewById(R.id.btn);
        sr = findViewById(R.id.sr);
    }

    private class MyTask extends AsyncTask<Integer, Integer, String> {




        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            zimu.setText("开始");
        }

        @Override
        protected String doInBackground(Integer... integers) {

            for (int i = integers[0]; i > 0; i--) {
                try {
                    Thread.sleep(1000);
                    publishProgress(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return "计时结束";
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
            zimu.setText(s);
            btn.setEnabled(false);
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            progressBar.setProgress(values[0]);
            zimu.setText(values[0]+"");
        }
    }

}
Execute和 executeOnExcutor有何区别？
***1、执行execute()方法线程可以只能串行运行
2、执行executeOnExecuter()方法线程并行运行，不过同一时间只能启动五个线程***

喜欢用AsyncTask还是Handler，为什么？

 我觉得使用Handler更好，其优点为:简单,快捷，过程可控。
 而AsyncTask在单个后台异步处理时，显得代码过多，结构过于复杂（相对性）