android多线程下载以及断点续传

转载自

使用多线程下载文件可以更快完成文件的下载，多线程下载文件之所以快，是因为其抢占的服务器资源多。如：假设服务器同时最多服务100个用户，在服务器中一条线程对应一个用户，100条线程在计算机中并非并发执行，而是由CPU划分 时间片轮流执行，如果A应用使用了99条线程下载文件，那么相当于占用了99个用户的资源，假设一秒内CPU分配给每条线程的平均执行时间是10ms，A应用在服务器中一秒内就得到了990ms的执行时间，而其他应用在一秒内只有10ms的执行时间。就如同一个水龙头，每秒出水量相等的情况下，放990毫秒的水

肯定比放10毫秒的水要多。

多线程下载的实现过程：

1>首先得到下载文件的长度，然后设置本地文件

的长度。

HttpURLConnection.getContentLength();

RandomAccessFile file = new RandomAccessFile("QQWubiSetup.exe","rwd");

file.setLength(filesize);//设置本地文件的长度

2>根据文件长度和线程数计算每条线程下载的数据长度和下载位置。如：文件的长度为6M，线程数为3，那么，每条线程下载的数据长度为2M，每条线程开始下载的位置如上图所示。

3>使用Http的Range头字段指定每条线程从文件的什么位置开始下载，下载到什么位置为止，如：指定从文件的2M位置开始下载，下载到位置(4M-1byte)为止，代码如下：

HttpURLConnection.setRequestProperty("Range", "bytes=2097152-4194303");

4>保存文件，使用 RandomAccessFile类指定每条线程从本地文件的什么位置开始写入数据。

RandomAccessFile threadfile = new RandomAccessFile("QQWubiSetup.exe ","rwd");

threadfile.seek(2097152);//从文件的什么位置开始写入数据

 

MulTreadDownload.java

[java]  view plain copy

1. import java.io.File;  
2. import java.io.IOException;  
3. import java.io.InputStream;  
4. import java.io.RandomAccessFile;  
5. import java.net.HttpURLConnection;  
6. import java.net.URL;  
7.   
8. public class MulThreadDownloadTest {  
9.       
10.     public static void main(String[] args) throws Exception{  
11.         new MulThreadDownloadTest().downlaod();  
12.     }  
13.   
14.     public void downlaod() throws Exception{  
15.         String path = "http://net.itcast.cn/QQWubiSetup.exe";  
16.         //文件的长度  
17.         URL url = new URL(path);  
18.         HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
19.         conn.setRequestMethod("GET");  
20.         conn.setConnectTimeout(5*1000);  
21.         int length = conn.getContentLength();//得到文件的长度  
22.         int threadnum = 5;  
23.         int block = length%threadnum==0 ? length/threadnum : length/threadnum+1;//计算每条线程下载的数据长度  
24.         File file = new File("QQWubiSetup.exe");  
25.         RandomAccessFile rfile = new RandomAccessFile(file, "rwd");  
26.         rfile.setLength(length);//把本地文件的长度设置为网络文件的长度  
27.         rfile.close();  
28.         for(int i=0 ; i < threadnum ; i++){  
29.             new DownloadThread(block, url, file ,i).start();  
30.         }  
31.     }  
32.   
33.     private final class DownloadThread extends Thread{  
34.         private int block;//每条线程下载的数据长度  
35.         private URL url;//下载路径  
36.         private File file;//本地文件  
37.         private int threaid;//线程id  
38.           
39.         public DownloadThread(int block, URL url, File file, int i) {  
40.             this.block = block;  
41.             this.url = url;  
42.             this.file = file;  
43.             this.threaid = i;  
44.         }  
45.   
46.         @Override  
47.         public void run() {  
48.             try {  
49.                 int startpos = threaid * block;//计算该线程从文件的什么位置开始下载  
50.                 int endpos = (threaid+1) * block - 1;//计算该线程下载到文件的什么位置结束  
51.                 HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
52.                 conn.setRequestMethod("GET");  
53.                 conn.setConnectTimeout(5*1000);  
54.                 conn.setRequestProperty("Range", "bytes="+ startpos+"-"+ endpos);  
55.                 InputStream inputStream = conn.getInputStream();  
56.                 RandomAccessFile rfile = new RandomAccessFile(file, "rwd");  
57.                 rfile.seek(startpos);  
58.                 byte[] buffer = new byte[1024];  
59.                 int len = 0;  
60.                 while( (len = inputStream.read(buffer)) != -1){  
61.                     rfile.write(buffer, 0, len);  
62.                 }  
63.                 rfile.close();  
64.                 inputStream.close();  
65.                 System.out.println("线程"+ (threaid+1)+ "下载完成");  
66.             } catch (Exception e) {  
67.                 e.printStackTrace();  
68.             }  
69.         }  
70.     }  
71. }  

实现断点续传

 

有两种方式可以保存断点数据：

1.通过文件的形式保存

2 通过数据库的方式保存，如果需要查询的话则要此种方式，即使用Sqllite保存

下面看看如何数据库保存

 

 

建立表结构

DBOpenHelper.java

[java]  view plain copy

1. import android.content.Context;  
2. import android.database.sqlite.SQLiteDatabase;  
3. import android.database.sqlite.SQLiteOpenHelper;  
4.   
5. public class DBOpenHelper extends SQLiteOpenHelper {  
6.     private static final String DBNAME = "itcast.db";  
7.     private static final int VERSION = 1;  
8.       
9.     public DBOpenHelper(Context context) {  
10.         super(context, DBNAME, null, VERSION);  
11.     }  
12.       
13.     @Override  
14.     public void onCreate(SQLiteDatabase db) {  
15.         db.execSQL("CREATE TABLE IF NOT EXISTS filedownlog (id integer primary key autoincrement, downpath varchar(100), threadid INTEGER, downlength INTEGER)");  
16.     }  
17.   
18.     @Override  
19.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
20.         db.execSQL("DROP TABLE IF EXISTS filedownlog");  
21.         onCreate(db);  
22.     }  
23.   
24. }  

如何操作表，实现对断点数据的一个操作

FileService.java

[java]  view plain copy

1. import java.util.HashMap;  
2. import java.util.Map;  
3.   
4. import android.content.Context;  
5. import android.database.Cursor;  
6. import android.database.sqlite.SQLiteDatabase;  
7. /** 
8.  * 业务bean 
9.  * 
10.  */  
11. public class FileService {  
12.     private DBOpenHelper openHelper;  
13.   
14.     public FileService(Context context) {  
15.         openHelper = new DBOpenHelper(context);  
16.     }  
17.     /** 
18.      * 获取每条线程已经下载的文件长度 
19.      * @param path 
20.      * @return 
21.      */  
22.     public Map<Integer, Integer> getData(String path){  
23.         SQLiteDatabase db = openHelper.getReadableDatabase();  
24.         Cursor cursor = db.rawQuery("select threadid, downlength from filedownlog where downpath=?", new String[]{path});  
25.         Map<Integer, Integer> data = new HashMap<Integer, Integer>();  
26.         while(cursor.moveToNext()){  
27.             data.put(cursor.getInt(0), cursor.getInt(1));  
28.         }  
29.         cursor.close();  
30.         db.close();  
31.         return data;  
32.     }  
33.     /** 
34.      * 保存每条线程已经下载的文件长度 
35.      * @param path 
36.      * @param map 
37.      */  
38.     public void save(String path,  Map<Integer, Integer> map){//int threadid, int position  
39.         SQLiteDatabase db = openHelper.getWritableDatabase();  
40.         db.beginTransaction();  
41.         try{  
42.             for(Map.Entry<Integer, Integer> entry : map.entrySet()){  
43.                 db.execSQL("insert into filedownlog(downpath, threadid, downlength) values(?,?,?)",  
44.                         new Object[]{path, entry.getKey(), entry.getValue()});  
45.             }  
46.             db.setTransactionSuccessful();  
47.         }finally{  
48.             db.endTransaction();  
49.         }  
50.         db.close();  
51.     }  
52.     /** 
53.      * 实时更新每条线程已经下载的文件长度 
54.      * @param path 
55.      * @param map 
56.      */  
57.     public void update(String path, Map<Integer, Integer> map){  
58.         SQLiteDatabase db = openHelper.getWritableDatabase();  
59.         db.beginTransaction();  
60.         try{  
61.             for(Map.Entry<Integer, Integer> entry : map.entrySet()){  
62.                 db.execSQL("update filedownlog set downlength=? where downpath=? and threadid=?",  
63.                         new Object[]{entry.getValue(), path, entry.getKey()});  
64.             }  
65.             db.setTransactionSuccessful();  
66.         }finally{  
67.             db.endTransaction();  
68.         }  
69.         db.close();  
70.     }  
71.     /** 
72.      * 当文件下载完成后，删除对应的下载记录 
73.      * @param path 
74.      */  
75.     public void delete(String path){  
76.         SQLiteDatabase db = openHelper.getWritableDatabase();  
77.         db.execSQL("delete from filedownlog where downpath=?", new Object[]{path});  
78.         db.close();  
79.     }  
80.       
81. }  

 

实现断点数据的保存

 

FileDownload.java 

[java]  view plain copy

1. import java.io.File;  
2. import java.io.RandomAccessFile;  
3. import java.net.HttpURLConnection;  
4. import java.net.URL;  
5. import java.util.LinkedHashMap;  
6. import java.util.Map;  
7. import java.util.UUID;  
8. import java.util.concurrent.ConcurrentHashMap;  
9. import java.util.regex.Matcher;  
10. import java.util.regex.Pattern;  
11. import cn.itcast.service.FileService;  
12.   
13. import android.content.Context;  
14. import android.util.Log;  
15. /** 
16.  * 文件下载器 
17.  * @author lihuoming@sohu.com 
18.  */  
19. public class FileDownloader {  
20.     private static final String TAG = "FileDownloader";  
21.     private Context context;  
22.     private FileService fileService;      
23.     /* 已下载文件长度 */  
24.     private int downloadSize = 0;  
25.     /* 原始文件长度 */  
26.     private int fileSize = 0;  
27.     /* 线程数 */  
28.     private DownloadThread[] threads;  
29.     /* 本地保存文件 */  
30.     private File saveFile;  
31.     /* 缓存各线程下载的长度*/  
32.     private Map<Integer, Integer> data = new ConcurrentHashMap<Integer, Integer>();  
33.     /* 每条线程下载的长度 */  
34.     private int block;  
35.     /* 下载路径  */  
36.     private String downloadUrl;  
37.     /** 
38.      * 获取线程数 
39.      */  
40.     public int getThreadSize() {  
41.         return threads.length;  
42.     }  
43.     /** 
44.      * 获取文件大小 
45.      * @return 
46.      */  
47.     public int getFileSize() {  
48.         return fileSize;  
49.     }  
50.     /** 
51.      * 累计已下载大小 
52.      * @param size 
53.      */  
54.     protected synchronized void append(int size) {  
55.         downloadSize += size;  
56.     }  
57.     /** 
58.      * 更新指定线程最后下载的位置 
59.      * @param threadId 线程id 
60.      * @param pos 最后下载的位置 
61.      */  
62.     protected void update(int threadId, int pos) {  
63.         this.data.put(threadId, pos);  
64.     }  
65.     /** 
66.      * 保存记录文件 
67.      */  
68.     protected synchronized void saveLogFile() {  
69.         this.fileService.update(this.downloadUrl, this.data);  
70.     }  
71.     /** 
72.      * 构建文件下载器 
73.      * @param downloadUrl 下载路径 
74.      * @param fileSaveDir 文件保存目录 
75.      * @param threadNum 下载线程数 
76.      */  
77.     public FileDownloader(Context context, String downloadUrl, File fileSaveDir, int threadNum) {  
78.         try {  
79.             this.context = context;  
80.             this.downloadUrl = downloadUrl;  
81.             fileService = new FileService(this.context);  
82.             URL url = new URL(this.downloadUrl);  
83.             if(!fileSaveDir.exists()) fileSaveDir.mkdirs();  
84.             this.threads = new DownloadThread[threadNum];                     
85.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
86.             conn.setConnectTimeout(5*1000);  
87.             conn.setRequestMethod("GET");  
88.             conn.setRequestProperty("Accept", "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");  
89.             conn.setRequestProperty("Accept-Language", "zh-CN");  
90.             conn.setRequestProperty("Referer", downloadUrl);   
91.             conn.setRequestProperty("Charset", "UTF-8");  
92.             conn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");  
93.             conn.setRequestProperty("Connection", "Keep-Alive");  
94.             conn.connect();  
95.             printResponseHeader(conn);  
96.             if (conn.getResponseCode()==200) {  
97.                 this.fileSize = conn.getContentLength();//根据响应获取文件大小  
98.                 if (this.fileSize <= 0) throw new RuntimeException("Unkown file size ");  
99.                           
100.                 String filename = getFileName(conn);  
101.                 this.saveFile = new File(fileSaveDir, filename);/* 保存文件 */  
102.                 Map<Integer, Integer> logdata = fileService.getData(downloadUrl);  
103.                 if(logdata.size()>0){  
104.                     for(Map.Entry<Integer, Integer> entry : logdata.entrySet())  
105.                         data.put(entry.getKey(), entry.getValue());  
106.                 }  
107.                 this.block = (this.fileSize % this.threads.length)==0? this.fileSize / this.threads.length : this.fileSize / this.threads.length + 1;  
108.                 if(this.data.size()==this.threads.length){  
109.                     for (int i = 0; i < this.threads.length; i++) {  
110.                         this.downloadSize += this.data.get(i+1);  
111.                     }  
112.                     print("已经下载的长度"+ this.downloadSize);  
113.                 }                 
114.             }else{  
115.                 throw new RuntimeException("server no response ");  
116.             }  
117.         } catch (Exception e) {  
118.             print(e.toString());  
119.             throw new RuntimeException("don't connection this url");  
120.         }  
121.     }  
122.     /** 
123.      * 获取文件名 
124.      */  
125.     private String getFileName(HttpURLConnection conn) {  
126.         String filename = this.downloadUrl.substring(this.downloadUrl.lastIndexOf('/') + 1);  
127.         if(filename==null || "".equals(filename.trim())){//如果获取不到文件名称  
128.             for (int i = 0;; i++) {  
129.                 String mine = conn.getHeaderField(i);  
130.                 if (mine == null) break;  
131.                 if("content-disposition".equals(conn.getHeaderFieldKey(i).toLowerCase())){  
132.                     Matcher m = Pattern.compile(".*filename=(.*)").matcher(mine.toLowerCase());  
133.                     if(m.find()) return m.group(1);  
134.                 }  
135.             }  
136.             filename = UUID.randomUUID()+ ".tmp";//默认取一个文件名  
137.         }  
138.         return filename;  
139.     }  
140.       
141.     /** 
142.      *  开始下载文件 
143.      * @param listener 监听下载数量的变化,如果不需要了解实时下载的数量,可以设置为null 
144.      * @return 已下载文件大小 
145.      * @throws Exception 
146.      */  
147.     public int download(DownloadProgressListener listener) throws Exception{  
148.         try {  
149.             RandomAccessFile randOut = new RandomAccessFile(this.saveFile, "rw");  
150.             if(this.fileSize>0) randOut.setLength(this.fileSize);  
151.             randOut.close();  
152.             URL url = new URL(this.downloadUrl);  
153.             if(this.data.size() != this.threads.length){  
154.                 this.data.clear();  
155.                 for (int i = 0; i < this.threads.length; i++) {  
156.                     this.data.put(i+1, 0);  
157.                 }  
158.             }  
159.             for (int i = 0; i < this.threads.length; i++) {  
160.                 int downLength = this.data.get(i+1);  
161.                 if(downLength < this.block && this.downloadSize<this.fileSize){ //该线程未完成下载时,继续下载                        
162.                     this.threads[i] = new DownloadThread(this, url, this.saveFile, this.block, this.data.get(i+1), i+1);  
163.                     this.threads[i].setPriority(7);  
164.                     this.threads[i].start();  
165.                 }else{  
166.                     this.threads[i] = null;  
167.                 }  
168.             }  
169.             this.fileService.save(this.downloadUrl, this.data);  
170.             boolean notFinish = true;//下载未完成  
171.             while (notFinish) {// 循环判断是否下载完毕  
172.                 Thread.sleep(900);  
173.                 notFinish = false;//假定下载完成  
174.                 for (int i = 0; i < this.threads.length; i++){  
175.                     if (this.threads[i] != null && !this.threads[i].isFinish()) {  
176.                         notFinish = true;//下载没有完成  
177.                         if(this.threads[i].getDownLength() == -1){//如果下载失败,再重新下载  
178.                             this.threads[i] = new DownloadThread(this, url, this.saveFile, this.block, this.data.get(i+1), i+1);  
179.                             this.threads[i].setPriority(7);  
180.                             this.threads[i].start();  
181.                         }  
182.                     }  
183.                 }                 
184.                 if(listener!=null) listener.onDownloadSize(this.downloadSize);  
185.             }  
186.             fileService.delete(this.downloadUrl);  
187.         } catch (Exception e) {  
188.             print(e.toString());  
189.             throw new Exception("file download fail");  
190.         }  
191.         return this.downloadSize;  
192.     }  
193.     /** 
194.      * 获取Http响应头字段 
195.      * @param http 
196.      * @return 
197.      */  
198.     public static Map<String, String> getHttpResponseHeader(HttpURLConnection http) {  
199.         Map<String, String> header = new LinkedHashMap<String, String>();  
200.         for (int i = 0;; i++) {  
201.             String mine = http.getHeaderField(i);  
202.             if (mine == null) break;  
203.             header.put(http.getHeaderFieldKey(i), mine);  
204.         }  
205.         return header;  
206.     }  
207.     /** 
208.      * 打印Http头字段 
209.      * @param http 
210.      */  
211.     public static void printResponseHeader(HttpURLConnection http){  
212.         Map<String, String> header = getHttpResponseHeader(http);  
213.         for(Map.Entry<String, String> entry : header.entrySet()){  
214.             String key = entry.getKey()!=null ? entry.getKey()+ ":" : "";  
215.             print(key+ entry.getValue());  
216.         }  
217.     }  
218.   
219.     private static void print(String msg){  
220.         Log.i(TAG, msg);  
221.     }  
222.       
223.     public static void main(String[] args) {  
224.     /*  FileDownloader loader = new FileDownloader(context, "http://browse.babasport.com/ejb3/ActivePort.exe", 
225.                 new File("D:\\androidsoft\\test"), 2); 
226.         loader.getFileSize();//得到文件总大小 
227.         try { 
228.             loader.download(new DownloadProgressListener(){ 
229.                 public void onDownloadSize(int size) { 
230.                     print("已经下载："+ size); 
231.                 }            
232.             }); 
233.         } catch (Exception e) { 
234.             e.printStackTrace(); 
235.         }*/  
236.     }  
237.   
238. }  

DownloadActivity.java

[java]  view plain copy

1. package cn.itcast.download;  
2.   
3. import java.io.File;  
4.   
5. import cn.itcast.net.download.DownloadProgressListener;  
6. import cn.itcast.net.download.FileDownloader;  
7.   
8. import android.app.Activity;  
9. import android.os.Bundle;  
10. import android.os.Environment;  
11. import android.os.Handler;  
12. import android.os.Message;  
13. import android.view.View;  
14. import android.widget.Button;  
15. import android.widget.EditText;  
16. import android.widget.ProgressBar;  
17. import android.widget.TextView;  
18. import android.widget.Toast;  
19.   
20. public class DownloadActivity extends Activity {  
21.     private ProgressBar downloadbar;  
22.     private EditText pathText;  
23.     private TextView resultView;  
24.     private Handler handler = new Handler(){  
25.   
26.         @Override  
27.         public void handleMessage(Message msg) {  
28.             switch (msg.what) {  
29.             case 1:  
30.                 int size = msg.getData().getInt("size");  
31.                 downloadbar.setProgress(size);  
32.                 float result = (float)downloadbar.getProgress()/ (float)downloadbar.getMax();  
33.                 int p = (int)(result*100);  
34.                 resultView.setText(p+"%");  
35.                 if(downloadbar.getProgress()==downloadbar.getMax())  
36.                     Toast.makeText(DownloadActivity.this, R.string.success, 1).show();  
37.                 break;  
38.   
39.             case -1:  
40.                 Toast.makeText(DownloadActivity.this, R.string.error, 1).show();  
41.                 break;  
42.             }  
43.               
44.         }         
45.     };  
46.       
47.     @Override  
48.     public void onCreate(Bundle savedInstanceState) {  
49.         super.onCreate(savedInstanceState);  
50.         setContentView(R.layout.main);  
51.           
52.         Button button = (Button)this.findViewById(R.id.button);  
53.         downloadbar = (ProgressBar)this.findViewById(R.id.downloadbar);  
54.         pathText = (EditText)this.findViewById(R.id.path);  
55.         resultView = (TextView)this.findViewById(R.id.result);  
56.         button.setOnClickListener(new View.OnClickListener() {            
57.             @Override  
58.             public void onClick(View v) {  
59.                 String path = pathText.getText().toString();  
60.                 if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){  
61.                     File dir = Environment.getExternalStorageDirectory();//文件保存目录  
62.                     download(path, dir);  
63.                 }else{  
64.                     Toast.makeText(DownloadActivity.this, R.string.sdcarderror, 1).show();  
65.                 }  
66.             }  
67.         });  
68.     }  
69.     //对于UI控件的更新只能由主线程(UI线程)负责，如果在非UI线程更新UI控件，更新的结果不会反映在屏幕上，某些控件还会出错  
70.     private void download(final String path, final File dir){  
71.         new Thread(new Runnable() {  
72.             @Override  
73.             public void run() {  
74.                 try {  
75.                     FileDownloader loader = new FileDownloader(DownloadActivity.this, path, dir, 3);  
76.                     int length = loader.getFileSize();//获取文件的长度  
77.                     downloadbar.setMax(length);  
78.                     loader.download(new DownloadProgressListener(){  
79.                         @Override  
80.                         public void onDownloadSize(int size) {//可以实时得到文件下载的长度  
81.                             Message msg = new Message();  
82.                             msg.what = 1;  
83.                             msg.getData().putInt("size", size);                           
84.                             handler.sendMessage(msg);  
85.                         }});  
86.                 } catch (Exception e) {  
87.                     Message msg = new Message();  
88.                     msg.what = -1;  
89.                     msg.getData().putString("error", "下载失败");  
90.                     handler.sendMessage(msg);  
91.                 }  
92.             }  
93.         }).start();  
94.           
95.     }  
96. }  

 

 

注意：//对于UI控件的更新只能由主线程(UI线程)负责，如果在非UI线程更新UI控件，更新的结果不会反映在屏幕上，某些控件还会出错

可以是通过消息队列的方式传递数据到主线程，实现进度更新