多线程断点续传研究之二
上篇文章写完，由于整体思路是正确的，但是没有真正形成多线程下载，所以对本身的代码进行关键点的检查，尤其在一些操作web请求的地方，看看是否有什么问题，最后发现显示的关闭HttpWebResponse对象，能稍微有所改进。
原文参看：
http://blog.csdn.net/Knight94/archive/2006/08/04/1018305.aspx
那么修改后的类，大致代码如下：
//--------------------------- Download File class ---------------------------------------
//---------------------------------------------------------------------------------------
//---File: clsNewDownloadFile
//---Description: The multi-download file class file using HttpWebRequest class
//---Author: Knight
//---Date: Aug.4, 2006
//---------------------------------------------------------------------------------------
//---------------------------{Download File class}---------------------------------------
namespace DownloadFile
{
using System;
using System.IO;
using System.Net;
using System.Text;
using System.Security;
using System.Threading;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Data;
/// <summary>
/// Download file info
/// </summary>
public class DownloadFileInfo
{
private string _RequestURL;
private string _ResponseURL;
private string _FileName;
private int _TotalSize;
private int _BlockLeftSize;
public string RequestURL
{
get{ return _RequestURL; }
}
public string ResponseURL
{
get{ return _ResponseURL; }
}
public string FileName
{
get{ return _FileName; }
}
public int TotalSize
{
get{ return _TotalSize;}
set{ _TotalSize = value;}
}
public int BlockLeftSize
{
get{ return _BlockLeftSize;}
set{ _BlockLeftSize = value;}
}
public DownloadFileInfo(
string RequestURL,
string ResponseURL,
string FileName,
int TotalSize,
int BlockLeftSize )
{
this._RequestURL = RequestURL;
this._ResponseURL = ResponseURL;
this._FileName = FileName;
this._TotalSize = TotalSize;
this._BlockLeftSize = BlockLeftSize;
}
public DownloadFileInfo(
string RequestURL,
string ResponseURL,
string FileName ):
this( RequestURL, ResponseURL, FileName, 0, 0 )
{
}
}
/// <summary>
/// Download event arguments
/// </summary>
public class DownLoadEventArgs : System.EventArgs
{
private DownloadFileInfo _DownloadFileInfo;
private int _Position;
private int _ReadCount;
private int _ThreadNO;
public DownloadFileInfo DownFileInfo
{
get{ return _DownloadFileInfo; }
}
public int StartPosition
{
get{ return _Position; }
}
public int ReadCount
{
get{ return _ReadCount; }
}
public int ThreadNO
{
get{ return _ThreadNO; }
}
public DownLoadEventArgs(
DownloadFileInfo DownFileInfo,
int nStartPostion,
int nReadCount,
int nThreadNO )
{
this._DownloadFileInfo = DownFileInfo;
this._Position = nStartPostion;
this._ReadCount = nReadCount;
this._ThreadNO = nThreadNO;
}
}
public delegate void DataReceivedEventHandler( DownLoadEventArgs e );
public delegate void ThreadFinishedHandler();
/// <summary>
/// class for sub-download threads
/// </summary>
public class SubDownloadThread
{
private readonly DownloadFileInfo _FileInfo;
private int _ThreadNO;
private int _Position;
private int _BlockSizeLeft;
public event DataReceivedEventHandler DataReceived;
private ThreadFinishedHandler _Finished;
private bool _IsStopped;
private Thread thdDownload;
public SubDownloadThread(
DownloadFileInfo DownFileInfo,
int ThreadNO,
int Position,
int BlockSizeLeft,
ThreadFinishedHandler Finished )
{
this._FileInfo = DownFileInfo;
this._ThreadNO = ThreadNO;
this._Position = Position;
this._BlockSizeLeft = BlockSizeLeft;
this._Finished = Finished;
}
/// <summary>
/// Start to create thread to download file
/// </summary>
public void StartDownload()
{
thdDownload = new Thread( new ThreadStart( this.Download ) );
thdDownload.Start();
}
/// <summary>
/// Stop current download-thread
/// </summary>
public void Stop()
{
_IsStopped = true;
if( thdDownload.ThreadState == System.Threading.ThreadState.Running )
thdDownload.Join( 10 );
Debug.WriteLine( string.Format( "Thread NO:{0} is stopped!" ,_ThreadNO ) );
}
/// <summary>
/// Function for sub-thread
/// </summary>
private void Download()
{
HttpWebResponse hwrp = null;
try
{
Debug.WriteLine( string.Format( "Thread NO:{0} begins to download!" ,_ThreadNO ) );
// Creat request by url
HttpWebRequest hwrq = (HttpWebRequest) WebRequest.Create(
new Uri( this._FileInfo.RequestURL ));
// Go to download position
hwrq.AddRange( _Position );
// Get response from request
hwrp = (HttpWebResponse) hwrq.GetResponse();
}
catch (Exception e)
{
Debug.WriteLine( e.Message );
return;
}
// download and write data from
Debug.WriteLine( string.Format( "Thread NO:{0} call function named DownloadData!" ,
_ThreadNO ) );
DownloadData( hwrp );
hwrp.Close();//Close response here
}
/// <summary>
/// Download data through web request
/// </summary>
/// <param name="Response"></param>
private void DownloadData( WebResponse Response )
{
const int BUFFER_SIZE = 0x10000;//64k buffer size
byte[] bBuffer = new byte[ BUFFER_SIZE ];
Stream sReader = Response.GetResponseStream();
if( sReader == null ) return;
int nReadCount = 0;
while( !_IsStopped && this._BlockSizeLeft > 0 )
{
Debug.WriteLine( string.Format( "Thread NO:{0} reads data!" ,
_ThreadNO ) );
// Set read size
nReadCount = ( BUFFER_SIZE > this._BlockSizeLeft )
? this._BlockSizeLeft:BUFFER_SIZE ;//Get current read count
// Read data
int nRealReadCount = sReader.Read( bBuffer, 0, nReadCount );
if( nRealReadCount <= 0 ) break;
Debug.WriteLine( string.Format( "Thread NO:{0} writes data!" ,
_ThreadNO ) );
// Write data
using( FileStream sw = new FileStream(
this._FileInfo.FileName,
System.IO.FileMode.OpenOrCreate,
System.IO.FileAccess.ReadWrite, System.IO.FileShare.ReadWrite))
{
sw.Position = this._Position;
sw.Write( bBuffer, 0, nRealReadCount );
Debug.WriteLine( string.Format( "Thread NO:{0} writes {1} data!" ,
_ThreadNO, nRealReadCount ) );
sw.Flush();
sw.Close();
}
Debug.WriteLine( string.Format( "Thread NO:{0} send callback info!" ,
_ThreadNO ) );
// Call back
DataReceived( new DownLoadEventArgs( this._FileInfo,
this._Position,
nRealReadCount,
this._ThreadNO ) );
// Set position and block left
this._Position += nRealReadCount;
this._BlockSizeLeft -= nRealReadCount;
}
if( _IsStopped ) return;
Debug.WriteLine( string.Format( "Thread NO:{0} sends finish-info!" ,
_ThreadNO ) );
_Finished();
}
}
/// <summary>
/// Class for download thread
/// </summary>
public class DownloadThread
{
private DownloadFileInfo _FileInfo;
private SubDownloadThread[] subThreads;
private int nThreadFinishedCount;
private DataRow drFileInfo;
private DataTable dtThreadInfo;
public DataReceivedEventHandler DataReceived;
public event ThreadFinishedHandler Finished;
/// Class's Constructor
public DownloadThread(
string RequestURL,
string ResponseURL,
string FileName,
DataRow NewFileInfo,
int SubThreadNum )
{
// Create download file info
_FileInfo = new DownloadFileInfo( RequestURL, ResponseURL, FileName );
// Create request to get file info
bool blnMultiDownload = GetFileDownInfo();
// Create file info datarow
drFileInfo = NewFileInfo;
InitDataRow();
// Create subthreads and set these info in threadinfo table
if( SubThreadNum <= 0 ) SubThreadNum = 5;//Defualt value
//Not support to be multi-thread download or less than 64k
if( !blnMultiDownload || _FileInfo.TotalSize <= 0x10000 ) SubThreadNum = 1;
subThreads = new SubDownloadThread[SubThreadNum];
nThreadFinishedCount = 0;
CreateThreadTable( SubThreadNum );
}
public DownloadThread( DataRow DownloadFileInfo, DataTable ThreadInfos )
{
// Create download file info
drFileInfo = DownloadFileInfo;
_FileInfo = new DownloadFileInfo(
drFileInfo["RequestURL"].ToString(),
drFileInfo["ResponseURL"].ToString(),
drFileInfo["FileName"].ToString(),
Convert.ToInt32( drFileInfo["TotalSize"].ToString() ),
Convert.ToInt32( drFileInfo["BlockLeftSize"].ToString() ) );
// Create sub thread class objects
dtThreadInfo = ThreadInfos;
subThreads = new SubDownloadThread[ dtThreadInfo.Rows.Count ];
nThreadFinishedCount = 0;
}
/// {Class's Constructor}
/// <summary>
/// Start to download
/// </summary>
public void Start()
{
StartSubThreads();
}
/// <summary>
/// Create table to save thread info
/// </summary>
/// <param name="SubThreadNum"></param>
private void CreateThreadTable( int SubThreadNum )
{
int nThunkSize = _FileInfo.TotalSize / SubThreadNum;
dtThreadInfo = new DataTable("DownloadFileInfo");
dtThreadInfo.Columns.Add( "ThreadNO", typeof(int) );
dtThreadInfo.Columns.Add( "Position", typeof(int) );
dtThreadInfo.Columns.Add( "BlockLeftSize", typeof(int) );
DataRow drNew;
int i = 0;
for( ; i < SubThreadNum-1; i++ )
{
drNew = dtThreadInfo.NewRow();
drNew["ThreadNO"] = i;
drNew["Position"] = i * nThunkSize;
drNew["BlockLeftSize"] = nThunkSize;
dtThreadInfo.Rows.Add( drNew );
}
drNew = dtThreadInfo.NewRow();
drNew["ThreadNO"] = i;
drNew["Position"] = i * nThunkSize;
drNew["BlockLeftSize"] = _FileInfo.TotalSize - i * nThunkSize;
dtThreadInfo.Rows.Add( drNew );
dtThreadInfo.AcceptChanges();
}
/// <summary>
/// Start sub-threads to download file
/// </summary>
private void StartSubThreads()
{
foreach( DataRow dr in dtThreadInfo.Rows )
{
int ThreadNO = Convert.ToInt32( dr["ThreadNO"].ToString() );
if( Convert.ToInt32( dr["BlockLeftSize"].ToString() ) > 0 )
{
subThreads[ ThreadNO ] = new SubDownloadThread(
_FileInfo,
ThreadNO,
Convert.ToInt32( dr["Position"].ToString() ),
Convert.ToInt32( dr["BlockLeftSize"].ToString() ),
new ThreadFinishedHandler( this.DownloadFinished ) );
subThreads[ ThreadNO ].DataReceived += this.DataReceived;
subThreads[ ThreadNO ].StartDownload();
}
else
DownloadFinished();
}
}
/// <summary>
/// Save download file info
/// </summary>
private void InitDataRow()
{
drFileInfo.BeginEdit();
drFileInfo["RequestURL"] = _FileInfo.RequestURL;
drFileInfo["ResponseURL"] = _FileInfo.ResponseURL;
drFileInfo["FileName"] = _FileInfo.FileName;
drFileInfo["TotalSize"] = _FileInfo.TotalSize;
drFileInfo["BlockLeftSize"] = _FileInfo.BlockLeftSize;
drFileInfo["CreatedTime"] = DateTime.Now.ToString( "yyyyMMddHHmmss" );
drFileInfo.EndEdit();
drFileInfo.AcceptChanges();
}
/// <summary>
/// Check url to get download file info
/// </summary>
/// <returns></returns>
private bool GetFileDownInfo()
{
HttpWebRequest hwrq;
HttpWebResponse hwrp = null;
try
{
//Create request
hwrq = (HttpWebRequest) WebRequest.Create( _FileInfo.RequestURL );
hwrp = (HttpWebResponse) hwrq.GetResponse();
//Get file size info
long L = hwrp.ContentLength;
L = ((L == -1) || (L > 0x7fffffff)) ? ((long) 0x7fffffff) : L;
_FileInfo.TotalSize = (int)L;
_FileInfo.BlockLeftSize = _FileInfo.TotalSize;
//Check whether this url is supported to be multi-threads download
bool blnMulti = ( hwrp.Headers["Accept-Ranges"] != null
&& hwrp.Headers["Accept-Ranges"] == "bytes");
hwrp.Close();//Close response here
return blnMulti;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Update download thread info
/// </summary>
/// <param name="ThreadNO"></param>
/// <param name="Position"></param>
/// <param name="DownloadSize"></param>
public void UpdateDownloadInfo( int ThreadNO, int Position, int DownloadSize )
{
if( ThreadNO >= dtThreadInfo.Rows.Count ) return;
DataRow drThreadNO = dtThreadInfo.Rows[ThreadNO];
drThreadNO["Position"] = Position + DownloadSize;
drThreadNO["BlockLeftSize"] = Convert.ToInt32( drThreadNO["BlockLeftSize"].ToString() )
- DownloadSize;
drThreadNO.AcceptChanges();
drFileInfo["BlockLeftSize"] = Convert.ToInt32( drFileInfo["BlockLeftSize"].ToString() )
- DownloadSize;
}
/// <summary>
/// Stop download threads
/// </summary>
public void Stop()
{
for( int i = 0; i < subThreads.Length; i++ )
subThreads[i].Stop();
}
/// <summary>
/// Thread download finished
/// </summary>
private void DownloadFinished()
{
// Some download thread finished
nThreadFinishedCount++;
if( nThreadFinishedCount == subThreads.Length )
{
// All download threads finished
drFileInfo.Delete();
//drFileInfo.AcceptChanges();
Finished();
}
}
public DataTable ThreadInfo
{
get{ return dtThreadInfo; }
}
}
}
不过对于这个类来说，我也只实现了两个线程同时下载，当初始化为3个以上线程的时候，就有等待线程出现，这一点和我用FlashGet看到现象一样，那么估计要支持多个线程，服务器需要做些设置，不过这些还需要进一步的验证。