多线程下载文件

作者：夏至 转载请保留这段申明
http://blog.csdn.net/u011418943/article/details/56675652

项目下载地址：
https://git.oschina.net/zhengshaorui/MtlThreadDownloadFile.git

上一章，我们实现了单线程的下载，这一章，我们实现一个简单的多线程下载，不先加断线续传，下一章再加断点续传。
上一章连接：http://blog.csdn.net/u011418943/article/details/56674086

首先，文件在下载中，我们常用的是用单线程下载，这样的好处在于好控制，能够监控这个文件的下载进度等等。缺点在于，没有完全利用cpu的利用率，而且如果是大文件，下载的速度较慢。所以，我们可以通过多线程的方式，去下载文件。
实现原理是什么呢？就是把一个文件给切分几块来下载。比如一个11M的文件，我们把它分成5个部分来下载；那么它的计算公式就为
blocksize = 11%5 == 0？ 11/5:11%5+1；

//每一个线程要下载的大小
 blocksize = filesize%threadcount == 0? filesize/threadcount : filesize/threadcount+1

图片摘自网络，如下：

理解了原理，我们来实现一个小demo，下载一个南方周末的apk，连为：http://images.infzm.com/mobile/infzmreader.apk
首先，先想一下，我们需要传递给线程下载的参数有哪些，无非就是 url，apk下载的路径，文件名字，和线程个数，当然可以根据需求，加你想要的参数。
首先权限先加：

<!--获取网络权限-->
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <!--在SDCard中创建与删除文件权限  -->
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
    <!-- 往SDCard写入数据权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <!--  从SDCard读取数据权限 -->
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

再写我们的实体类，跟上一章一样

public class FilesInfo implements Serializable {
    private String fileUrl;
    private String fileName;
    private String fileDir;
    private int threadcount;
    public FilesInfo(String fileUrl, int threadcount, String fileDir, String fileName) {
        this.fileUrl = fileUrl;
        this.threadcount = threadcount;
        this.fileDir = fileDir;
        this.fileName = fileName;
    }
    public int getThreadcount() {
        return threadcount;
    }
    public void setThreadcount(int threadcount) {
        this.threadcount = threadcount;
    }
    public int getPriority() {
        return priority;
    }
    public String getFileUrl() {
        return fileUrl;
    }
    public void setFileUrl(String fileUrl) {
        this.fileUrl = fileUrl;
    }
    public String getFileName() {
        return fileName;
    }
    public void setFileName(String fileName) {
        this.fileName = fileName;
    }
    public String getFileDir() {
        return fileDir;
    }
    public void setFileDir(String fileDir) {
        this.fileDir = fileDir;
    }
}

这里，我用到了Serializable 这个属性来传递参数，毕竟我们是通过启动service 来启动线程的，用这个传递可以少去代码臃肿。然后在 onclick 那里，启动我们的服务：

public void download(View view){
       FilesInfo filesInfo = new FilesInfo(apkUrl,5,fileDir,"南方周末");
        Intent downloadservice = new Intent(MainActivity.this,DownloadManager.class);
        downloadservice.putExtra("fileinfo",filesInfo);
        startService(downloadservice);
    }

接着，我们在onStartCommand 这里获取我们的数据，然后开启我们的线程。

public int onStartCommand(Intent intent, int flags, int startId) {
        FilesInfo mFilesInfo = (FilesInfo) intent.getSerializableExtra("fileinfo");
        startdownload(mFilesInfo.getFileUrl(),mFilesInfo.getFileDir(),mFilesInfo.getFileName(),
                mFilesInfo.getThreadcount(),mFilesInfo.getPriority());
        return super.onStartCommand(intent, flags, startId);
    }

其中 startdownload 如下：

private void startdownload(String apkUrl, String fileDir, String filename, int threadcount
            , int priority) {
        File dir  = new File(fileDir);
        if (!dir.exists()){
            dir.mkdir();
        }
        String filepath =  filename;
            downloadManager downloadManager = new    downloadManager(apkUrl,dir,filepath,threadcount,priority);
        downloadManger.start();
    }

downloadManager 是我们下载的实现方法，代码如下：

class downloadManager extends  Thread{
        String apkurl,filepath;
        int threadcount,priority;
        int blocksize; //每个线程需要下载的区域
        File dir;
        public downloadManager(String apkUrl,File dir, String filepath, int threadcount, int priority) {
            this.apkurl = apkUrl;
            this.filepath = filepath;
            this.threadcount = threadcount;
            this.priority = priority;
            this.dir = dir;
        }
        @Override
        public void run() {
            HttpURLConnection con = null;
            try {
                DownloadTask[]  mDownloadTasks = new DownloadTask[threadcount];
                URL url = new URL(this.apkurl);
                con = (HttpURLConnection) url.openConnection();
                con.setRequestMethod("GET");
                con.setReadTimeout(5000);
                con.setConnectTimeout(5000);
                int filesize = con.getContentLength(); //获取文件总长度
                if (filesize <= 0){
                    Log.d(TAG, "文件获取失败");
                    return;
                }
                //每一个线程要下载的大小
                blocksize = filesize%threadcount == 0? filesize/threadcount : filesize/threadcount+1;
                Log.d(TAG, "filesize: "+filesize+" blocksize: "+blocksize);
                File file = new File(this.filepath);
                for (int i = 0; i < mDownloadTasks.length; i++) { //根据线程数，开启线程
                    mDownloadTasks[i] = new DownloadTask(url,dir,filepath,blocksize,
                            i,threadcount,filesize);

                      mDownloadTasks[i].start();
                }
                boolean isfinished = false;
                int filelength = 0;
                while(!isfinished){  //这里用来判断是否下载完成，不加去掉也行
                    isfinished = true;
                    filelength = 0;
                    for (int i = 0; i < mDownloadTasks.length; i++) {
                        if (!mDownloadTasks[i].isCompleted()){
                            isfinished = false;
                        }else{
                            filelength += mDownloadTasks[i].getDownloadLength();
                        }
                    }
                }
                Log.d(TAG, "finished: "+filelength+" "+filesize);
            } catch (Exception e) {
                e.printStackTrace();
            }
            super.run();
        }
    }

其中，DownloadTask 为我们的下载类，代码如下：

public class DownloadTask extends Thread{
    private static final String TAG = "zsr";
    public DownloadTask(){
    }
    private boolean isCompleted = false;
    private URL connectUrl;
    private File dir;
    private int blocksize,threadid;
    private int downloadLength = 0;
    private int threadcount;
    private int filelength;
    private String filename;
    public DownloadTask(URL connectUrl, File dir, String filename,int blocksize, int threadid,
                        int threadcount,int filelength){
        this.connectUrl = connectUrl;
        this.dir = dir;
        this.blocksize = blocksize;
        this.threadid = threadid;
        this.threadcount = threadcount;
        this.filelength = filelength;
        this.filename = filename;
    }
    @Override
    public void run() {
        RandomAccessFile raf = null;
        BufferedInputStream bis = null;
        HttpURLConnection con = null;
        try {
            con = (HttpURLConnection) connectUrl.openConnection();
            con.setRequestMethod("GET");
            con.setReadTimeout(5000);
            con.setConnectTimeout(5000);
            int startpos = blocksize * threadid; //开始位置
            int endpos = blocksize * (threadid+1) -1; //结束位置
            if (threadid == (threadcount -1)) endpos = filelength;
            //设置下载位置
            con.setRequestProperty("Range", "bytes="+startpos+"-"+endpos);
            Log.d(TAG, "range: "+startpos+" "+endpos);
            //设置文件的写入位置
            File file = new File(dir,filename);
            raf = new RandomAccessFile(file,"rwd");
            raf.seek(startpos);
            //读数据
            bis = new BufferedInputStream(con.getInputStream());
            byte[] bytes = new byte[1024*4];
            int len = -1;
            while( (len = bis.read(bytes)) !=-1 ){
                raf.write(bytes,0,len);
                downloadLength += len;
            }
            isCompleted = true;
            Log.d(TAG, "finish: "+downloadLength);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bis != null) try {
                bis.close();
                if (raf != null) raf.close();
             } catch (IOException e) {
                e.printStackTrace();
            }
            if (con != null) con.disconnect();
        }
        super.run();
    }
    public boolean isCompleted() {
        return isCompleted;
    }
    public int getDownloadLength(){
        return downloadLength;
    }
}

代码，没啥好解释的，跟一般的文件下载差不多，只不过这里是分块的形式，所以，random 属性那里，start 和end 要做一下判断：

    int startpos = blocksize * threadid; //开始位置
            int endpos = blocksize * (threadid+1) -1; //结束位置
            if (threadid == (threadcount -1)) endpos = filelength; //最后一个结尾，以文件的长度结尾

2、用线程池管理

在上面中，我们都是直接 start(） 启动我们的线程，在多个线程的线程的时候，我们这种做法是很不对的，因为线程的开启和销毁，是需要时间的，这个时候，线程就会在内存一直占用着，这样的后果是你的内存一直在上升；假如你把这个回收了，过一会又要启动了，这个启动和销毁也是耗资源的。
这个时候，线程池的作用就出来了，顾名思义，线程池，就是线程组织的一个池塘，它由 Excutors 创建和管理。用线程池的好处如下：

1. 在同事并发执行线程时，提高API的性能
2. 减少线程的重复开启、销毁
3. 减少内存消耗，控制线程数量

线程池，共有四种，分别如下：newCachedThreadPool() ：

• cacheThreadPool 缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中。能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。缓存型池子通常用于执行一些生存期很短的异步型任务 。
• newFixedThreadPool() fixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程 其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子。和cacheThreadPool不同：fixedThreadPool池线程数固定，但是0秒IDLE（无IDLE）。这也就意味着创建的线程会一直存在。所以fixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器。
• newScheduledThreadPool() 调度型线程池。这个池子里的线程可以按schedule依次delay执行，或周期执行 。0秒IDLE（无IDLE）。
• SingleThreadExecutor 单例线程，任意时间池中只能有一个线程 。用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）。

由于，我们是用到一个下载器的作用，所以，我们这里采用 newFixedThreadPool 固定并发的线程池，那么怎么用？很简单，把线程的start() 方法，用 线程池的 excute 就行了。如：

private ExecutorService mExecutorService = Executors.newFixedThreadPool(5);//固定线程并发数量为5

// mDownloadTasks[i].start();
 mExecutorService.execute(mDownloadTasks[i]);

log 如下：