asynctask使用_androidstudiohelloworld教程

/** * author: zyinux * date: on 2018/10/26 */
public class DownloadTask extends AsyncTask<String,Integer,Boolean> {

    ProgressDialog progressDialog;

    Context context;

    public DownloadTask(Context context) {
        this.context=context;

    }

    @Override
    protected void onPreExecute() {
        progressDialog=new ProgressDialog(context);
        progressDialog.setMax(100);
    // progressDialog.setCancelable(false);
    //注意这里我将上一行代码注释掉，使得dialog能够被取消，至于为什么这么做后面解释
        progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        progressDialog.show();
    }

    @Override
    protected Boolean doInBackground(String... strings) {
        int pro=0;

        while (true){
            pro++;
            publishProgress(pro);
            if (pro>=100){
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        return true;
    }

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

    @Override
    protected void onPostExecute(Boolean aBoolean) {
        progressDialog.dismiss();
        if (aBoolean){
            Toast.makeText(context,"下载成功",Toast.LENGTH_SHORT).show();
        }else {
            Toast.makeText(context,"下载失败",Toast.LENGTH_SHORT).show();
        }
    }
}
复制代码

new DownloadTask(this).execute("testurl");
//使用非常简单，new 之后执行execute传入执行的参数即可
复制代码

public class DownloadTask extends AsyncTask<String,Integer,Boolean> 复制代码

protected void onPreExecute() {}
protected Boolean doInBackground(String... strings) {}
protected void onProgressUpdate(Integer... values) {}
protected void onPostExecute(Boolean aBoolean) { }
复制代码

// progressDialog.setCancelable(false);
//注意这里我将上一行代码注释掉，使得dialog能够被取消，至于为什么这么做后面解释
复制代码

    @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

    接着继续看

    @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) {
        //看这里我们直到onPreExecute方法一定在doInBackground方法之前调用，并且是在UI Thread
        onPreExecute();
        /** *具体执行方法在这里 我们直到这个exec就是上一步传进来的sDefaultExecutor *这是一个用来管理线程池的框架 */
        exec.execute(mFuture);
        return this;
    }

    初始化的地方，重点这里初始化为static final 是一个类静态变量，是类实例共享的
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();    

    继续看这个SerialExecutor
    private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    将任务保存在ArrayDeque中，这是一个FIFO的队列，最后执行这个队列中的每一个任务。所以当执行多个AsyncTask时，他们是串行执行的。
复制代码

上面说了这时一般情况，那么特殊情况呢？
复制代码

DownloadTask task=new DownloadTask(this);
task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
复制代码

public final boolean cancel(boolean mayInterruptIfRunning) {}
复制代码