<!-- 在SD卡中创建与删除文件权限 -->
<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
<!-- 向SD卡写入数据权限 -->
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<!-- 授权访问网络 -->
<uses-permission android:name="android.permission.INTERNET"/>

package com.example.ljd.asynctask;

import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

 private DownloadAsyncTask mDownloadAsyncTask;

 private Button mButton;
 private String[] path = {
   "http://msoftdl.360.cn/mobilesafe/shouji360/360safesis/360MobileSafe_6.2.3.1060.apk",
   "http://dlsw.baidu.com/sw-search-sp/soft/7b/33461/freeime.1406862029.exe",
 };

 @Override
 protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_main);
  mButton = (Button)findViewById(R.id.button);
  mButton.setOnClickListener(this);
 }

 @Override
 protected void onDestroy() {
  if (mDownloadAsyncTask != null){
   mDownloadAsyncTask.cancel(true);
  }
  super.onDestroy();
 }

 @Override
 public void onClick(View v) {

  mDownloadAsyncTask = new DownloadAsyncTask();
  mDownloadAsyncTask.execute(path);
 }

 class DownloadAsyncTask extends AsyncTask<String,Integer,Boolean>{

  private ProgressDialog mPBar;
  private int fileSize;  //下载的文件大小
  @Override
  protected void onPreExecute() {
   super.onPreExecute();
   mPBar = new ProgressDialog(MainActivity.this);
   mPBar.setProgressNumberFormat(" KB/%2d KB");
   mPBar.setTitle("下载");
   mPBar.setMessage("正在下载，请稍后...");
   mPBar.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
   mPBar.setCancelable(false);
   mPBar.show();
  }

  @Override
  protected Boolean doInBackground(String... params) {
   //下载图片
   for (int i=0;i<params.length;i++){
    try{
     if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
      URL url = new URL(params[i]);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      //设置超时时间
      conn.setConnectTimeout(5000);
      //获取下载文件的大小
      fileSize = conn.getContentLength();
      InputStream is = conn.getInputStream();
      //获取文件名称
      String fileName = path[i].substring(path[i].lastIndexOf("/") + 1);
      File file = new File(Environment.getExternalStorageDirectory(), fileName);
      FileOutputStream fos = new FileOutputStream(file);
      BufferedInputStream bis = new BufferedInputStream(is);
      byte[] buffer = new byte[1024];
      int len ;
      int total = 0;
      while((len =bis.read(buffer))!=-1){
       fos.write(buffer, 0, len);
       total += len;
       publishProgress(total);
       fos.flush();
      }
      fos.close();
      bis.close();
      is.close();
     }
     else{
      return false;
     }
    }catch (IOException e){
     e.printStackTrace();
     return false;
    }
   }

   return true;
  }

  @Override
  protected void onPostExecute(Boolean aBoolean) {
   super.onPostExecute(aBoolean);
   mPBar.dismiss();
   if (aBoolean){
    Toast.makeText(MainActivity.this,"下载完成",Toast.LENGTH_SHORT).show();
   } else {
    Toast.makeText(MainActivity.this,"下载失败",Toast.LENGTH_SHORT).show();
   }
  }

  @Override
  protected void onProgressUpdate(Integer... values) {
   super.onProgressUpdate(values);
   mPBar.setMax(fileSize / 1024);
   mPBar.setProgress(values[0]/1024);
  }
 }

}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:padding="@dimen/activity_vertical_margin"
  android:orientation="vertical"
  tools:context="com.example.ljd.asynctask.MainActivity">

  <Button
    android:id="@+id/button"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="download"/>
</LinearLayout>

@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) {
  if (mStatus != Status.PENDING) {
    switch (mStatus) {
      case RUNNING:
        throw new IllegalStateException("Cannot execute task:"
            + " the task is already running.");
      case FINISHED:
        throw new IllegalStateException("Cannot execute task:"
            + " the task has already been executed "
            + "(a task can be executed only once)");
    }
  }

  mStatus = Status.RUNNING;

  onPreExecute();

  mWorker.mParams = params;
  exec.execute(mFuture);

  return this;
}

private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;

......

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
  Params[] mParams;
}

public AsyncTask() {
  mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception {
      mTaskInvoked.set(true);

      Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
      //noinspection unchecked
      Result result = doInBackground(mParams);
      Binder.flushPendingCommands();
      return postResult(result);
    }
  };

  mFuture = new FutureTask<Result>(mWorker) {
    @Override
    protected void done() {
      try {
        postResultIfNotInvoked(get());
      } catch (InterruptedException e) {
        android.util.Log.w(LOG_TAG, e);
      } catch (ExecutionException e) {
        throw new RuntimeException("An error occurred while executing doInBackground()",
            e.getCause());
      } catch (CancellationException e) {
        postResultIfNotInvoked(null);
      }
    }
  };
}

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;

private static final ThreadFactory sThreadFactory = new ThreadFactory() {
  private final AtomicInteger mCount = new AtomicInteger(1);

  public Thread newThread(Runnable r) {
    return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
  }
};

private static final BlockingQueue<Runnable> sPoolWorkQueue =
    new LinkedBlockingQueue<Runnable>(128);

public static final Executor THREAD_POOL_EXECUTOR
    = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
        TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

......

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

......

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);
    }
  }
}

public void run() {
  if (state != NEW ||
    !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
    return;
  try {
    Callable<V> c = callable;
    if (c != null && state == NEW) {
      V result;
      boolean ran;
      try {
        result = c.call();
        ran = true;
      } catch (Throwable ex) {
        result = null;
        ran = false;
        setException(ex);
      }
      if (ran)
        set(result);
    }
  } finally {
    // runner must be non-null until state is settled to
    // prevent concurrent calls to run()
    runner = null;
    // state must be re-read after nulling runner to prevent
    // leaked interrupts
    int s = state;
    if (s >= INTERRUPTING)
      handlePossibleCancellationInterrupt(s);
  }
}

public Result call() throws Exception {
  mTaskInvoked.set(true);

  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
  //noinspection unchecked
  Result result = doInBackground(mParams);
  Binder.flushPendingCommands();
  return postResult(result);
}

private Result postResult(Result result) {
  @SuppressWarnings("unchecked")
  Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
      new AsyncTaskResult<Result>(this, result));
  message.sendToTarget();
  return result;
}

private static class InternalHandler extends Handler {
  public InternalHandler() {
    super(Looper.getMainLooper());
  }

  @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
  @Override
  public void handleMessage(Message msg) {
    AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
    switch (msg.what) {
      case MESSAGE_POST_RESULT:
        // There is only one result
        result.mTask.finish(result.mData[0]);
        break;
      case MESSAGE_POST_PROGRESS:
        result.mTask.onProgressUpdate(result.mData);
        break;
    }
  }
}

private void finish(Result result) {
  if (isCancelled()) {
    onCancelled(result);
  } else {
    onPostExecute(result);
  }
  mStatus = Status.FINISHED;
}