Sorta
zhouyiran2 发表于 2014-1-5 16:27
1.请记住，建立连接是需要时间的，所有多线程的优势在于较大一些的文件上会有一定优势，但在assets资源中 ...

第一种多线程同源多线程

  2.     import java.io.File;   
  3.     import java.io.IOException;   
  4.     import java.io.InputStream;   
  5.     import java.io.RandomAccessFile;   
  6.     import java.net.HttpURLConnection;   
  7.     import java.net.URL;   
  8.     /**  
  9.      * 多线程方式文件下载  
  10.      */   
  11.     public class MulThreadDownload {   
  12.         /* 下载的URL */   
  13.         private URL downloadUrl;   
  14.         /* 用于保存的本地文件 */   
  15.         private File localFile;   
  16.         /* 没条线程下载的数据长度 */   
  17.         private int block;   
  18.         public static void main(String[] args) {   
  19.             /* 可以为网络上任意合法下载地址 */   
  20.             String downPath = "http://192.168.1.102:8080/myvideoweb/down.avi";   
  21.             MulThreadDownload threadDownload = new MulThreadDownload();   
  22.             /* 开 10 条线程下载下载 */   
  23.             try {   
  24.                 threadDownload.download(downPath, 10);   
  25.             } catch (Exception e) {   
  26.                 e.printStackTrace();   
  27.             }   
  28.         }   
  29.         /**  
  30.          * 多线程文件下载  
  31.          *   
  32.          * @param path 下载地址  
  33.          * @param threadCount 线程数  
  34.          */   
  35.         public void download(String path, int threadCount) throws Exception {   
  36.             downloadUrl = new URL(path);   
  37.             HttpURLConnection conn = (HttpURLConnection) downloadUrl   
  38.                     .openConnection();   
  39.             /* 设置 GET 请求方式 */   
  40.             conn.setRequestMethod("GET");   
  41.             /* 设置响应时间超时为 5 秒 */   
  42.             conn.setConnectTimeout(5 * 1000);   
  43.             /* 获取本地文件名 */   
  44.             String filename = parseFilename(path);   
  45.             /* 获取下载文件的总大小 */   
  46.             int dataLen = conn.getContentLength();   
  47.             if (dataLen < 0) {   
  48.                 System.out.println("获取数据失败");   
  49.                 return;   
  50.             }   
  51.             /* 创建本地目标文件，并设置其大小为准备下载文件的总大小 */   
  52.             localFile = new File(filename);   
  53.             RandomAccessFile accessFile = new RandomAccessFile(localFile, "rwd");   
  54.             /* 这时候，其实本地目录下，已经创建好了一个大小为下载文件的总大小的文件 */   
  55.             accessFile.setLength(dataLen);   
  56.             accessFile.close();   
  57.             /* 计算每条线程要下载的数据大小 */   
  58.             block = dataLen % threadCount == 0 ? dataLen / threadCount : dataLen / threadCount + 1;   
  59.             /* 启动线程下载文件 */   
  60.             for (int i = 0; i < threadCount; i++) {   
  61.                 new DownloadThread(i).start();   
  62.             }   
  63.         }   
  64.         /**  
  65.          * 解析文件  
  66.          */   
  67.         private String parseFilename(String path) {   
  68.             return path.substring(path.lastIndexOf("/") + 1);   
  69.         }   
  70.         /**  
  71.          * 内部类： 文件下载线程类  
  72.          */   
  73.         private final class DownloadThread extends Thread {   
  74.             /* 线程 id */   
  75.             private int threadid;   
  76.             /* 开始下载的位置 */   
  77.             private int startPosition;   
  78.             /* 结束下载的位置 */   
  79.             private int endPosition;   
  80.             /**  
  81.              * 新建一个下载线程  
  82.              * @param threadid 线程 id  
  83.              */   
  84.             public DownloadThread(int threadid) {   
  85.                 this.threadid = threadid;   
  86.                 startPosition = threadid * block;   
  87.                 endPosition = (threadid + 1) * block - 1;   
  88.             }   
  89.             @Override   
  90.             public void run() {   
  91.                 System.out.println("线程 '" + threadid + "'启动下载..");   
  92.                     
  93.                 RandomAccessFile accessFile = null;   
  94.                 try {   
  95.                     /* 设置从本地文件的什么位置开始写入数据 ,"rwd" 表示对文件具有读写删权限 */   
  96.                     accessFile = new RandomAccessFile(localFile, "rwd");   
  97.                     accessFile.seek(startPosition);   
  98.                     HttpURLConnection conn = (HttpURLConnection) downloadUrl.openConnection();   
  99.                     conn.setRequestMethod("GET");   
  100.                     conn.setReadTimeout(5 * 1000);   
  101.                     /* 为 HTTP 设置 Range 属性，可以指定服务器返回数据的范围 */   
  102.                     conn.setRequestProperty("Range", "bytes=" + startPosition + "-"   
  103.                             + endPosition);   
  104.                     /* 将数据写往本地文件 */   
  105.                     writeTo(accessFile, conn);   
  106.                         
  107.                     System.out.println("线程 '" + threadid + "'完成下载");   
  108.                 } catch (IOException e) {   
  109.                     e.printStackTrace();   
  110.                 } finally {   
  111.                     try {   
  112.                         if(accessFile != null) {   
  113.                             accessFile.close();   
  114.                         }   
  115.                      } catch (IOException ex) {   
  116.                          ex.printStackTrace();   
  117.                      }   
  118.                 }   
  119.             }   
  120.             /**  
  121.              * 将下载数据写往本地文件  
  122.              */   
  123.             private void writeTo(RandomAccessFile accessFile,   
  124.                     HttpURLConnection conn){   
  125.                 InputStream is = null;   
  126.                 try {   
  127.                     is = conn.getInputStream();   
  128.                     byte[] buffer = new byte[1024];   
  129.                     int len = -1;   
  130.                     while ((len = is.read(buffer)) != -1) {   
  131.                         accessFile.write(buffer, 0, len);   
  132.                     }   
  133.                 } catch (IOException e) {   
  134.                     e.printStackTrace();   
  135.                 } finally {   
  136.                     try {   
  137.                         if(is != null) {   
  138.                             is.close();   
  139.                         }     
  140.                     } catch (Exception ex) {   
  141.                         ex.printStackTrace();   
  142.                     }   
  143.                 }   
  144.             }   
  145.         }   
  146.     }   
复制代码
第二种就不是同源多线程

显而易见的 这两种肯定都比单线程快

但是如果我写这段代码的话 我懒得用多线程
zhouyiran2
Sorta 发表于 2014-1-5 16:49
第一种多线程同源多线程第二种就不是同源多线程

显而易见的 这两种肯定都比单线程快

1.我问你，is = conn.getInputStream();  需要时间么？如果一个文件只有几百B或几K，你说哪个效率高？建立Http连接、创建线程都是要系统资源、时间的！
Sorta
zhouyiran2 发表于 2014-1-5 16:58
1.我问你，is = conn.getInputStream();  需要时间么？如果一个文件只有几百B或几K，你说哪个效率高？建立 ...

请自行尝试
zhouyiran2
Sorta 发表于 2014-1-5 17:00
请自行尝试

你自行尝试过吗？
huanghongxun
表示只是为了省事不想写多线程。
zhh0000zhh
刚看到。。。
感谢你的好意。。
不过我刚才试了一下，多线程下载对于大资源文件加速极为明显，最大可达到理论速度（线程数*单线程速度）
至于小文件从没想过使用多线程。。。
zhouyiran2
zhh0000zhh 发表于 2014-4-26 10:45
刚看到。。。
感谢你的好意。。
不过我刚才试了一下，多线程下载对于大资源文件加速极为明显，最大可达到理 ...

谢谢，那个已经经过了实验，证明速度慢和我的下载器的缺陷有一定关系，准备对WebClient进行改造来避免问题
zhh0000zhh
zhouyiran2 发表于 2014-4-26 11:01
谢谢，那个已经经过了实验，证明速度慢和我的下载器的缺陷有一定关系，准备对WebClient进行改造来避免问 ...

WebClient没有任何前途。。。
用httpresponse自己写吧
zhouyiran2
zhh0000zhh 发表于 2014-4-26 14:25
WebClient没有任何前途。。。
用httpresponse自己写吧

我说的是WebClient的网络部分写得还是可以的，至少效果比我自己写出来的好，准备好好看看到底差别问题出在哪里
zhh0000zhh
zhouyiran2 发表于 2014-4-26 15:23
我说的是WebClient的网络部分写得还是可以的，至少效果比我自己写出来的好，准备好好看看到底差别问题出在 ...

好吧。。。。。
第一页 上一页