java下的Http多线程下载与断点续传分析【转自酷勤网】

　　这个版本中加入了断点续传的功能，使用了XML文件保存任务列表及状态信息，并且支持多线程分段下载, 提高下载速度，在这一个版本中，我把它叫做: JLoading 因为我还想不出一个更好听一点或更酷一些的名字，而且我还想让他可以下载一些其它文件。

   上次的 - “Mp3在线搜索工具”还有很多可以改进的地方，也得到一些朋友的建议，非常感谢。这个版本中加入了断点续传的功能，使用了XML文件保存任务列表及状态 信息，并且支持多线程分段下载, 提高下载速度，在这一个版本中，我把它叫做: JLoading 因为我还想不出一个更好听一点或更酷一些的名字，而且我还想让他可以下载一些其它文件。程序不想做大，但想做得极致一些，比如从速度上。欢迎交流学习, huliqing(huliqing@live.com)

协议针对于Http,先谈一下简单原理。因为代码太多，在这里只取重点分析。

    如果你对http协议比较了解，那么你应该已经知道原理了，只要在请求头中加入以下代码就可以只请求部分数据： Content-Range: bytes 20000-40000/47000 ,
即从第20000字节请求到第40000个字节,(文件长度是47000字节).知道了这一点之后，请求数据就非常容易了，

只要利用Java中的URL，先探测数据的长度，然后再将这个长度分片段进行多段程下载就可以了，以下是我的实现方式：

//  对文件进行分块
         try  {
            totalBytes  =   new  URL(url).openConnection().getContentLength();
             if  (totalBytes  ==   - 1 ) state  =  STATE_NONE;
        }  catch  (IOException ioe) {
             return ;
        }
         //  创建分块，并创建相应的负责下载的线程
         long  pieceSize  =  ( long ) Math.ceil(( double ) totalBytes  /  ( double ) threads);
         long  pStart  =   0 ;
         long  pEnd  =   0 ;
        tasksAll.clear();
        tasks.clear();
         for  ( int  i  =   0 ; i  <  threads; i ++ ) {
             if  (i  ==   0 ) {
                pStart  =  pieceSize  *  i;
            }
             if  (i  ==  threads  -   1 ) {
                pEnd  =  totalBytes;
            }  else  {
                pEnd  =  pStart  +  pieceSize;
            }
            Piece piece  =   new  Piece(pStart, pStart, pEnd);
            tasksAll.add(piece);
            tasks.add(piece);
            pStart  =  pEnd  +   1 ;
        }

 

  程序根据线程数目划分成相应的分片信息(Piece)并放入任务列表中，由线程池中的线程去负责下载，每个线程负责一个片段（Piece),当线程下载完自己的分片之后并不立即消毁，而是到任务队列中继续获取任务，

若任务池为空,则将自己放入空闲池中并等待新任务，其他线程在发现有空闲线程时，则将自己所负责的任务分片再进行切割，并放入到任务队列中，同时唤醒空闲线程帮助下载，这样不会出现懒惰线程，也可以实现动态增删线程的功能,注意的是一些线程同步的问题。

 

public   void  run() {
         while  ( ! dl.isOk()) {
            
             //  暂停任务
            synchronized ( this ) {
                 if  (dl.isPaused()) {
                     try  {
                         this .wait();
                    }  catch  (InterruptedException e) {
                    }
                }
            }
            
             //  中断停止
             if  (Thread.interrupted()  ||  dl.isStopped()) {
                 return ;
            }
            
             //  等待获取任务
            Piece piece;
            synchronized (tasks) {
                 while  (tasks.isEmpty()) {
                     if  (dl.isOk())  return ;
                     try  {
                        tasks.wait();
                         // System.out.println(this.getName() + ":wait");
                    }  catch  (InterruptedException ie) {
                         // System.out.println(this.getName() + 
                         //         ":InterruptedException:" + ie.getMessage());
                    }
                }
                piece  =  tasks.remove( 0 );
                dl.removeFreeLoader( this );
                 // System.out.println(this.getName() + ":loading");
            }
             try  {
                URL u  =   new  URL(dl.getURL());
                URLConnection uc  =  u.openConnection();
                 //  设置断点续传位置
                uc.setAllowUserInteraction( true );
                uc.setRequestProperty( " Range " ,  " bytes= "   +  piece.getPos()  +   " - "   +  piece.getEnd());
                 in   =   new  BufferedInputStream(uc.getInputStream());

                 out   =   new  RandomAccessFile(dl.getFileProcess(),  " rw " );
                 out .seek(piece.getPos());  //  设置指针位置

                 long  start;
                 long  end;
                 int  len  =   0 ;
                 while  (piece.getPos()  <  piece.getEnd()) {
                    start  =  System.currentTimeMillis();
                    len  =   in .read(buff,  0 , buff.length);
                     if  (len  ==   - 1 )  break ;
                     out .write(buff,  0 , len);
                    end  =  System.currentTimeMillis();
                    timeUsed  +=  end  -  start;     //  累计时间使用
                    
                     long  newPos  =  piece.getPos()  +  len;
                    
                     //  如果该区段已经完成,如果该线程负责的区域已经完成，或出界
                     if  (newPos  >  piece.getEnd()) {
                        piece.setPos(piece.getEnd());   
                         long  offset  =  newPos  -  piece.getEnd();
                         long  trueReads  =  (len  -  offset  +   1 );
                        dl.growReadBytes(trueReads);     //  修正偏移量
                        dl.setOffsetTotal(dl.getOffsetTotal()  +  trueReads);
                        readBytes  +=  trueReads;
                         // System.out.println(this.getName() + ":read=" + trueReads);
                    }  else  {
                        dl.growReadBytes(len);
                        piece.setPos(piece.getPos()  +  len);
                        readBytes  +=  len;
                         // System.out.println(this.getName() + ":read=" + len);
                    }
                     //  如果存在空闲的任务线程，则切割出新的区域至任务队列中。由空闲
                     //  的线程辅助下载
                     if  (dl.isFreeLoader()) {
                        Piece newPiece  =  piece.cutPiece();
                         if  (newPiece  !=   null ) {
                            synchronized (tasks) {
                                dl.addTask(newPiece);
                                dl.setRepairCount(dl.getRepairCount()  +   1 );  //  增加切割次数
                                tasks.notifyAll();   //  唤醒等待任务中的空闲线程
                            }
                        }
                        
                    }
                     //  暂停任务
                    synchronized ( this ) {
                         if  (dl.isPaused()) {
                             try  {
                                 this .wait();
                            }  catch  (InterruptedException e) {
                            }
                        }
                    }
                    
                     //  中断停止
                     if  (Thread.interrupted()  ||  dl.isStopped()) {
                         in .close();
                         out .close();
                         return ;
                    }
                     // System.out.println(this.getName() + ":read:" + dl.getReadBytes());
                }
                 out .close();
                 in .close(); 
                dl.addFreeLoader( this );
                 // System.out.println("切割次数：" + dl.getRepairCount());
                 if  (dl.isOk()) dl.processWhenOk();
            }  catch  (IOException e) {
                 // System.out.println(this.getName() + ":无法读取数据");
            }
        }
    }

 

这里使用了RandomAccessFile进行保存本地文件，使用RandomAccessFile可以快速移动指针。另外一个就是需要在运行过程中，记得定时保存分片信息，以免在程序意外崩溃的情况下无法正常保存状态信息。
程序可能还存在一些不足并且还有很多可以改进的地方。

以下是状态文件Config的XML结构,这里记录了每个任务的运行状态,piece作为每个分段的状态，在程序重启之后载入这个配置文件,并在下载完成之后删除这一文件.另外主目录还有一个task.xml文件，用于记录所有下载任务，及状态文件的位置。

<? xml version="1.0" encoding="UTF-8" standalone="no" ?>
< file  id ="1207786769343_4046.6321122755676"  
    length ="3895507"  
    name ="读你  36首经典精选"  
    save ="C:\Documents and Settings\huliqing.TBUY-HULIQING\桌面\dist\musics\读你  36首经典精选[1].mp3"  
    threads ="12" >
< urls >
     < url  src ="http://zlq.zust.edu.cn/Uploadfiles/wlhx/20071224220653927.mp3" />
</ urls >
< pieces >
     < piece  end ="324626"  pos ="20767"  start ="0" />
     < piece  end ="649253"  pos ="419439"  start ="324627" />
     < piece  end ="973880"  pos ="892414"  start ="649254" />
     < piece  end ="1298507"  pos ="1068702"  start ="973881" />
     < piece  end ="1623134"  pos ="1318124"  start ="1298508" />
     < piece  end ="1947761"  pos ="1706453"  start ="1623135" />
     < piece  end ="2272388"  pos ="1987815"  start ="1947762" />
     < piece  end ="2597015"  pos ="2535705"  start ="2272389" />
     < piece  end ="2921642"  pos ="2671690"  start ="2597016" />
     < piece  end ="3246269"  pos ="3176315"  start ="2921643" />
     < piece  end ="3570896"  pos ="3522551"  start ="3246270" />
     < piece  end ="3895507"  pos ="3678693"  start ="3570897" />
</ pieces >

 

评论：

# re: Http多线程下载与断点续传分析[未登录]2008-04-10 09:18 | Frank

你的程序下载的时候很快，但合并文件的时候没有用到多线程，所以下载完毕后，文件不能立即就使用

# re: Http多线程下载与断点续传分析2008-04-10 09:28 | ljwan12

提供下载速度，单靠多线程是不行的，比如你选择的一个下载源，他的速度本来就很慢，这样你即使使用很多线程连接，速度也不会有多大的提高。
我认为有两种方法可以提高：
（1）、使用P2P，但此对于你的这个估计没多大效果，因为这个小软件的使用人数不多，同时下载某一个文件的概率太小。
（2）、选择更快的下载源，你的程序是通过百度MP3搜索查找歌曲，你可以通过程序来判断某一个下载源的速度，选择最快的一个。本人认为这种实现对于你的这个程序比较有效。
迅雷下载速度很快，他结合了很多种技术。
本人的一点建议，仅供参考！！

# re: Http多线程下载与断点续传分析2008-04-10 09:35 | huliqing

@Frank
我使用的是多个RandomAccessFile同时利用一个File对象写同一个文件，操作系统本身会同步对文件的写操作。在利用多个File对象写同一个文件时，遇到一些问题, 另外我认为速度的瓶颈主要还是来自网络，本地文件读写应该不会是什么大问题。:)  

# re: Http多线程下载与断点续传分析2008-04-10 09:40 | huliqing

@ljwan12
<urls>
<url src="http://zlq.zust.edu.cn/Uploadfiles/wlhx/20071224220653927.mp3"/>
</urls>
呵呵，我在配置文件中预留这一个，我想，在有可能的情况下让程序从多个下载源中进行文件下载。有时候我们会搜到很多同文件而不同URL的源地址。利用这个应该可以更好的提升速度  

# re: Http多线程下载与断点续传分析2008-04-10 14:48 | ljwan12

@huliqing
你的想法，在其他的很多下载软件中就是这么实现的，但是这个实现起来就比较复杂了，你还得建立自己的后台服务器来保存这些资源的一些信息，另外还有一个更加重要的是你需要有一套很好的机制来判断是否是完全一样的！！！
可以参考一些开源下载软件的代码，他们实现的都比较好！比如电驴