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

2024-06-11 18:58
文章标签 android 多线程 下载 断点续传

本文主要是介绍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控件，更新的结果不会反映在屏幕上，某些控件还会出错
可以是通过消息队列的方式传递数据到主线程，实现进度更新

这篇关于android多线程下载以及断点续传的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1052016。

相关文章

常用的jdk下载地址

常用的jdk下载地址

jdk下载地址 安装方式可以看之前的博客： mac安装jdk oracle 版本：https://www.oracle.com/java/technologies/downloads/ Eclipse Temurin版本：https://adoptium.net/zh-CN/temurin/releases/ 阿里版本： github：https://github.com/
阅读更多...
Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸： 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  （注意不能是bmp格式） 替换默认锁屏壁纸： 将图片资源放入vendo
阅读更多...
Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

Android平台播放RTSP流的几种方案探究（VLC VS ExoPlayer VS SmartPlayer）

技术背景 好多开发者需要遴选Android平台RTSP直播播放器的时候，不知道如何选的好，本文针对常用的方案，做个大概的说明： 1. 使用VLC for Android VLC Media Player（VLC多媒体播放器），最初命名为VideoLAN客户端，是VideoLAN品牌产品，是VideoLAN计划的多媒体播放器。它支持众多音频与视频解码器及文件格式，并支持DVD影音光盘，VCD影
阅读更多...
android-opencv-jni

android-opencv-jni

//------------------start opencv--------------------@Override public void onResume(){ super.onResume(); //通过OpenCV引擎服务加载并初始化OpenCV类库，所谓OpenCV引擎服务即是 //OpenCV_2.4.3.2_Manager_2.4_*.apk程序包，存
阅读更多...
从状态管理到性能优化：全面解析 Android Compose

从状态管理到性能优化：全面解析 Android Compose

文章目录 引言一、Android Compose基本概念1.1 什么是Android Compose?1.2 Compose的优势1.3 如何在项目中使用Compose 二、Compose中的状态管理2.1 状态管理的重要性2.2 Compose中的状态和数据流2.3 使用State和MutableState处理状态2.4 通过ViewModel进行状态管理 三、Compose中的列表和滚动
阅读更多...
2. 下载rknn-toolkit2项目

2. 下载rknn-toolkit2项目

官网链接： https://github.com/airockchip/rknn-toolkit2 安装好git：[[1. Git的安装]] 下载项目： git clone https://github.com/airockchip/rknn-toolkit2.git 或者直接去github下载压缩文件，解压即可。
阅读更多...
多线程解析报表

多线程解析报表

假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要提示解析完成。 Way1 join import java.time.LocalTime;public class Main {public static void main(String[] args) thro
阅读更多...
Android 10.0 mtk平板camera2横屏预览旋转90度横屏拍照图片旋转90度功能实现

Android 10.0 mtk平板camera2横屏预览旋转90度横屏拍照图片旋转90度功能实现

1.前言 在10.0的系统rom定制化开发中，在进行一些平板等默认横屏的设备开发的过程中，需要在进入camera2的 时候，默认预览图像也是需要横屏显示的，在上一篇已经实现了横屏预览功能，然后发现横屏预览后，拍照保存的图片 依然是竖屏的，所以说同样需要将图片也保存为横屏图标了，所以就需要看下mtk的camera2的相关横屏保存图片功能， 如何实现实现横屏保存图片功能 如图所示: 2.mtk
阅读更多...
android应用中res目录说明

android应用中res目录说明

Android应用的res目录是一个特殊的项目，该项目里存放了Android应用所用的全部资源，包括图片、字符串、颜色、尺寸、样式等，类似于web开发中的public目录，js、css、image、style。。。。 Android按照约定，将不同的资源放在不同的文件夹中，这样可以方便的让AAPT(即Android Asset Packaging Tool , 在SDK的build-tools目
阅读更多...
Android fill_parent、match_parent、wrap_content三者的作用及区别

Android fill_parent、match_parent、wrap_content三者的作用及区别

这三个属性都是用来适应视图的水平或者垂直大小，以视图的内容或尺寸为基础的布局，比精确的指定视图的范围更加方便。 1、fill_parent 设置一个视图的布局为fill_parent将强制性的使视图扩展至它父元素的大小 2、match_parent 和fill_parent一样，从字面上的意思match_parent更贴切一些，于是从2.2开始，两个属性都可以使用，但2.3版本以后的建议使
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2