vc++ 实现多线程断点续传

结合FTP类，http类，实现多线程断点续传

// DownloadMTR.cpp: implementation of the CDownloadMTR class.

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "downtest.h"

#include "DownloadMTR.h"

#include <io.h>

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

void DownloadNotify ( int nIndex, UINT nNotityType, LPVOID lpNotifyData, LPVOID pDownloadMTR );

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CDownloadMTR::CDownloadMTR()

: m_nThreadCount ( DEFAULT_THREAD_COUNT )

, m_pDownloadPub_MTR ( NULL )

, m_pDownloadPub_Info ( NULL )

, m_pDownloadCellInfo ( NULL )

, m_hThread ( NULL )

, m_bForceDownload ( FALSE )

, m_nTotalDownloadedSize_ThisTimes ( 0 )

{

memset ( &m_BaseDownInfo, 0, sizeof(t_BaseDownInfo) );

m_hEvtEndModule = ::CreateEvent ( NULL, TRUE, FALSE, NULL );

m_dwDownloadStartTime = GetTickCount();

}

CDownloadMTR::~CDownloadMTR()

{

StopDownload ();

}

//

// 设置下载的线程数

//

BOOL CDownloadMTR::SetThreadCount(int nThreadCount)

{

if ( nThreadCount <= 0 || nThreadCount > MAX_DOWNLOAD_THREAD_COUNT )

{

Log ( L_WARNING, "Thread count %d is invalid. Rang [%d-%d]", nThreadCount, 1, MAX_DOWNLOAD_THREAD_COUNT );

return FALSE;

}

if ( nThreadCount == m_nThreadCount )

return TRUE;

m_nThreadCount = nThreadCount;

return TRUE;

}

//

// 下载任务的线程函数

//

DWORD WINAPI ThreadProc_DownloadMTR(

LPVOID lpParameter // thread data

)

{

CDownloadMTR *pDownloadMTR = (CDownloadMTR*)lpParameter;

ASSERT ( pDownloadMTR );

pDownloadMTR->ThreadProc_DownloadMTR ();

TRACE ( "下载任务的线程函数 执行完毕/n" );

return TRUE;

}

BOOL CDownloadMTR::ThreadProc_DownloadMTR()

{

// 启动多线程下载任务

int nRet = StartMTRDownload ();

if ( nRet == 2 ) return HandleDownloadFinished(ENUM_DOWNLOAD_RESULT_SUCCESS);

if ( nRet == 0 ) return HandleDownloadFinished(ENUM_DOWNLOAD_RESULT_FAILED);

// 等待所有线程下载完成

ENUM_DOWNLOAD_RESULT eDownloadResult = WaitForDownloadFinished ();

if ( eDownloadResult == ENUM_DOWNLOAD_RESULT_SUCCESS && !GetDownloadResult () )

{

eDownloadResult = ENUM_DOWNLOAD_RESULT_FAILED;

}

return HandleDownloadFinished ( eDownloadResult );

}

//

// 多线程断点续传下载一个文件

//

BOOL CDownloadMTR::Download (

LPCTSTR lpszDownloadURL,

LPCTSTR lpszSavePath,

LPCTSTR lpszSaveOnlyFileName,

LPCTSTR lpszUsername/*=NULL*/,

LPCTSTR lpszPassword/*=NULL*/,

BOOL bForceDownload/*=FALSE*/ // 如果为 TRUE 表示强制性重新下载，以下载的部分将会被删除，FALSE 表示断点续传

)

{

if ( !HANDLE_IS_VALID(m_hEvtEndModule) )

return FALSE;

if ( !lpszSavePath || strlen(lpszSavePath) < 1 )

return FALSE;

m_csSavePath = lpszSavePath;

m_csSaveOnlyFileName = GET_SAFE_STRING(lpszSaveOnlyFileName);

m_bForceDownload = bForceDownload;

CString csServer, csObject;

USHORT nPort = 0;

if ( !ParseURL ( lpszDownloadURL, csServer, csObject, nPort, m_csProtocolType ) )

{

Log ( L_ERROR, "Download URL [%s] invalid", lpszDownloadURL );

return FALSE;

}

m_csDownloadURL = lpszDownloadURL;

// 创建取站点信息对象

if ( !( m_pDownloadPub_Info = CreateDownloadObject () ) )

{

Log ( L_ERROR, "Create download object failed" );

return HandleDownloadFinished(ENUM_DOWNLOAD_RESULT_FAILED);

}

// 设置取站点信息对象的参数

m_pDownloadPub_Info->SetAuthorization ( lpszUsername, lpszPassword );

m_pDownloadPub_Info->m_pDownloadMTR = this;

m_pDownloadPub_Info->SetDownloadUrl ( lpszDownloadURL );

// 创建一个下载线程

DWORD dwThreadId = 0;

m_hThread = CreateThread ( NULL, 0, ::ThreadProc_DownloadMTR, LPVOID(this), 0, &dwThreadId );

if ( !HANDLE_IS_VALID(m_hThread) )

{

Log ( L_WARNING, "Create download thread failed" );

return FALSE;

}

return TRUE;

}

//

// 创建下载对象

//

CDownloadPub* CDownloadMTR::CreateDownloadObject ( int nCount/*=1*/ )

{

if ( nCount < 1 ) return NULL;

CDownloadPub *pDownloadPub = NULL;

if ( m_csProtocolType.CompareNoCase ( "http" ) == 0 )

{

pDownloadPub = (CDownloadPub*)new CDownloadHttp[nCount];

}

else if ( m_csProtocolType.CompareNoCase ( "ftp" ) == 0 )

{

pDownloadPub = (CDownloadPub*)new CDownloadFtp[nCount];

}

else return NULL;

return pDownloadPub;

}

//

// 删除下载对象

//

void CDownloadMTR::DeleteDownloadObject ( CDownloadPub *pDownloadPub )

{

if ( m_csProtocolType.CompareNoCase ( "http" ) == 0 )

{

delete[] ( (CDownloadHttp*)pDownloadPub );

}

else if ( m_csProtocolType.CompareNoCase ( "ftp" ) == 0 )

{

delete[] ( (CDownloadFtp*)pDownloadPub );

}

else delete[] pDownloadPub;

}

void Callback_SaveDownloadInfo ( int nIndex, int nDownloadedSize, int nSimpleSaveSize, WPARAM wParam )

{

CDownloadMTR *pDownloadMTR = (CDownloadMTR*)wParam;

ASSERT ( pDownloadMTR );

pDownloadMTR->Callback_SaveDownloadInfo ( nIndex, nDownloadedSize, nSimpleSaveSize );

}

void CDownloadMTR::Callback_SaveDownloadInfo ( int nIndex, int nDownloadedSize, int nSimpleSaveSize )

{

if ( nIndex >= 0 && nIndex < m_nThreadCount )

{

m_pDownloadCellInfo[nIndex].nDownloadedSize = nDownloadedSize;

if ( nDownloadedSize > 0 )

{

m_CSFor_DownloadedData.Lock();

m_nTotalDownloadedSize_ThisTimes += nSimpleSaveSize;

m_CSFor_DownloadedData.Unlock ();

}

}

}

//

// 创建多线程下载使用的对象和数据缓冲

//

BOOL CDownloadMTR::CreateDownloadObjectAndDataMTR ()

{

DeleteDownloadObjectAndDataMTR ();

ASSERT ( !m_pDownloadPub_MTR && m_pDownloadPub_Info );

m_pDownloadPub_MTR = CreateDownloadObject ( m_nThreadCount );

// 设置多线程下载使用的对象的参数

if ( m_pDownloadPub_MTR )

{

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

m_pDownloadPub_MTR[nIndex].m_nIndex = nIndex;

m_pDownloadPub_MTR[nIndex].m_pDownloadMTR = this;

m_pDownloadPub_MTR[nIndex].Set_SaveDownloadInfo_Callback ( ::Callback_SaveDownloadInfo, WPARAM(this) );

m_pDownloadPub_MTR[nIndex].SetAuthorization ( m_pDownloadPub_Info->Get_UserName(), m_pDownloadPub_Info->Get_GetPassword() );

m_pDownloadPub_MTR[nIndex].SetDownloadUrl ( m_csDownloadURL );

if ( !m_pDownloadPub_MTR[nIndex].SetSaveFileName ( GetTempFilePath() ) )

return FALSE;

}

}

// 创建多线程下载使用的数据缓冲

ASSERT ( !m_pDownloadCellInfo );

m_pDownloadCellInfo = new t_DownloadCellInfo[m_nThreadCount];

if ( m_pDownloadCellInfo )

memset ( m_pDownloadCellInfo, 0, m_nThreadCount*sizeof(t_DownloadCellInfo) );

if ( m_pDownloadPub_MTR != NULL && m_pDownloadCellInfo != NULL )

return TRUE;

Log ( L_WARNING, "Create MTR download object or buffer failed" );

return FALSE;

}

//

// 删除多线程下载使用的对象和数据缓冲

//

void CDownloadMTR::DeleteDownloadObjectAndDataMTR()

{

if ( m_pDownloadPub_MTR )

{

DeleteDownloadObject ( m_pDownloadPub_MTR );

m_pDownloadPub_MTR = NULL;

}

if ( m_pDownloadCellInfo )

{

delete[] m_pDownloadCellInfo;

m_pDownloadCellInfo = NULL;

}

}

//

// 删除取站点信息的下载对象

//

void CDownloadMTR::DeleteDownloadObject_Info()

{

if ( m_pDownloadPub_Info )

{

DeleteDownloadObject ( m_pDownloadPub_Info );

m_pDownloadPub_Info = NULL;

}

}

//

// 启动多线程下载，返回 0 表示失败，1表示成功，2表示不用下载了，因为该文件已经下载过了

//

int CDownloadMTR::StartMTRDownload ()

{

m_dwDownloadStartTime = GetTickCount();

DownloadNotify ( -1, NOTIFY_TYPE_START_DOWNLOAD, (LPVOID)NULL, this );

// 先获取站点信息

ASSERT ( m_pDownloadPub_Info );

if ( !m_pDownloadPub_Info->GetRemoteSiteInfo () )

return 0;

DbgLog ( "要下载的文件大小是： %d 字节/n", m_pDownloadPub_Info->Get_FileTotalSize () );

StandardSaveFileName ();

CFileStatus fileStatus;

if ( m_bForceDownload )

{

// 需要重新下载

::DeleteFile ( m_csSavePathFileName );

::DeleteFile ( GetTempFilePath() );

}

else

{

// 要保存的文件是否已经存在，且大小和创建时间一致，如果不是强制性下载，则不需要再下载了。

if ( CFile::GetStatus(m_csSavePathFileName,fileStatus) )

{

if (

(

fileStatus.m_mtime.GetTime() - m_pDownloadPub_Info->Get_TimeLastModified() <=2 &&

m_pDownloadPub_Info->Get_TimeLastModified()-fileStatus.m_mtime.GetTime() <=2

)

&&

fileStatus.m_size == m_pDownloadPub_Info->Get_FileTotalSize ()

&&

!m_bForceDownload

)

{

return 2;

}

}

}

BOOL bMustCreateNullFile = TRUE;

// 读取下载信息，如果能读到说明上次下载尚未完成

if ( !m_bForceDownload && m_pDownloadPub_Info->Is_SupportResume() )

{

if ( CFile::GetStatus(GetTempFilePath(),fileStatus) &&

fileStatus.m_size == m_pDownloadPub_Info->Get_FileTotalSize()+GetDownloadInfoWholeSize() )

{

if ( ReadDownloadInfo () )

bMustCreateNullFile = FALSE;

}

}

if ( bMustCreateNullFile )

{

int nFileSize = m_pDownloadPub_Info->Get_FileTotalSize();

int nTempFileSize = nFileSize+GetDownloadInfoWholeSize();

if ( nFileSize < 0 || !m_pDownloadPub_Info->Is_SupportResume() )

nTempFileSize = 0;

// 创建一个用来保存下载数据的空文件

if ( !CreateNullFile ( GetTempFilePath(), nTempFileSize ) )

return FALSE;

}

// 分配下载任务

if ( !AssignDownloadTask () )

{

Log ( L_WARNING, "Assign task failed" );

return 0;

}

m_dwDownloadStartTime = GetTickCount();

return 1;

}

//

// 得到临时数据保存的路径文件名

//

CString CDownloadMTR::GetTempFilePath ()

{

ASSERT ( !m_csSavePathFileName.IsEmpty () );

CString csTempFileName;

csTempFileName.Format ( "%s.~xhw~", m_csSavePathFileName );

::SetFileAttributes ( csTempFileName, FILE_ATTRIBUTE_HIDDEN );

return csTempFileName;

}

//

// 分配下载任务

//

BOOL CDownloadMTR::AssignDownloadTask()

{

ASSERT ( m_pDownloadPub_Info );

if ( !m_pDownloadPub_Info->Is_SupportResume() )

{

DeleteDownloadObjectAndDataMTR ();

Log ( L_WARNING, "Site [%s] not support resume download", m_pDownloadPub_Info->Get_ServerName() );

}

// 文件大小未知，采用单线程

if ( m_pDownloadPub_Info->Get_FileTotalSize () <= 0 || !m_pDownloadPub_Info->Is_SupportResume() )

{

if ( m_nThreadCount != 1 )

{

DeleteDownloadObjectAndDataMTR ();

SetThreadCount ( 1 );

}

}

if ( !DownloadInfoIsValid() || !m_pDownloadPub_MTR || !m_pDownloadCellInfo )

{

if ( !CreateDownloadObjectAndDataMTR () )

return FALSE;

}

ASSERT ( m_pDownloadPub_MTR && m_pDownloadCellInfo );

// 下载任务尚未分配

if ( !DownloadInfoIsValid() )

{

int nWillDownloadSize = -1, nWillDownloadStartPos = 0, nNoAssignSize = 0;

if ( m_pDownloadPub_Info->Get_FileTotalSize () > 0 )

{

nWillDownloadSize = m_pDownloadPub_Info->Get_FileTotalSize () / m_nThreadCount;

// 均分后剩下的部分，让第一个线程来承担下载

nNoAssignSize = m_pDownloadPub_Info->Get_FileTotalSize () % m_nThreadCount;

}

DbgLog ( "任务分配如下：--------------------/n" );

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

m_pDownloadCellInfo[nIndex].nWillDownloadStartPos = nWillDownloadStartPos;

m_pDownloadCellInfo[nIndex].nWillDownloadSize = nWillDownloadSize;

if ( nIndex == 0 && m_pDownloadPub_Info->Get_FileTotalSize () > 0 )

{

m_pDownloadCellInfo[nIndex].nWillDownloadSize += nNoAssignSize;

}

DbgLog ( "线程.%d 从 %d(0x%08x) 下载到 %d(0x%08x) 共 %d(0x%08x) 字节/n", nIndex,

m_pDownloadCellInfo[nIndex].nWillDownloadStartPos, m_pDownloadCellInfo[nIndex].nWillDownloadStartPos,

m_pDownloadCellInfo[nIndex].nWillDownloadStartPos+m_pDownloadCellInfo[nIndex].nWillDownloadSize,

m_pDownloadCellInfo[nIndex].nWillDownloadStartPos+m_pDownloadCellInfo[nIndex].nWillDownloadSize,

m_pDownloadCellInfo[nIndex].nWillDownloadSize, m_pDownloadCellInfo[nIndex].nWillDownloadSize );

nWillDownloadStartPos += m_pDownloadCellInfo[nIndex].nWillDownloadSize;

}

}

// 启动下载任务

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

if ( !m_pDownloadPub_MTR[nIndex].Download ( m_pDownloadCellInfo[nIndex].nWillDownloadStartPos,

m_pDownloadCellInfo[nIndex].nWillDownloadSize, m_pDownloadCellInfo[nIndex].nDownloadedSize ) )

return FALSE;

}

m_BaseDownInfo.dwThreadCount = m_nThreadCount;

return TRUE;

}

//

// 从下载信息文件中读取下载信息

//

BOOL CDownloadMTR::ReadDownloadInfo()

{

CString csTempFileName = GetTempFilePath ();

BOOL bRet = FALSE;

CFile file;

TRY

{

if ( file.Open ( csTempFileName, CFile::modeCreate|CFile::modeNoTruncate|CFile::modeReadWrite|CFile::typeBinary|CFile::shareDenyNone ) )

{

if ( file.Seek ( -(int)sizeof(t_BaseDownInfo), CFile::end ) == (int)(file.GetLength() - sizeof(t_BaseDownInfo)) )

{

if ( (UINT)file.Read ( &m_BaseDownInfo, sizeof(t_BaseDownInfo) ) == sizeof(t_BaseDownInfo) )

{

if ( (m_BaseDownInfo.dwThreadCount > 0 && m_BaseDownInfo.dwThreadCount <= MAX_DOWNLOAD_THREAD_COUNT)&&

SetThreadCount ( m_BaseDownInfo.dwThreadCount ) )

{

if ( CreateDownloadObjectAndDataMTR () )

{

if ( file.Seek ( -GetDownloadInfoWholeSize(), CFile::end ) == int(file.GetLength() - GetDownloadInfoWholeSize()) )

{

if ( file.Read ( m_pDownloadCellInfo, sizeof(t_DownloadCellInfo)*m_nThreadCount ) == sizeof(t_DownloadCellInfo)*m_nThreadCount )

{

bRet = TRUE;

}

else

{

memset ( m_pDownloadCellInfo, 0, sizeof(t_DownloadCellInfo)*m_nThreadCount );

}

}

}

}

}

}

}

}

CATCH( CFileException, e )

{

e->Delete ();

bRet = FALSE;

}

END_CATCH

if ( HANDLE_IS_VALID(file.m_hFile) )

file.Close ();

return bRet;

}

BOOL CDownloadMTR::SaveDownloadInfo ()

{

if ( !m_pDownloadPub_Info->Is_SupportResume() )

return TRUE;

CString csTempFileName = GetTempFilePath ();

BOOL bRet = FALSE;

CFile file;

TRY

{

if ( file.Open ( csTempFileName, CFile::modeCreate|CFile::modeNoTruncate|CFile::modeReadWrite|CFile::typeBinary|CFile::shareDenyNone ) )

{

if ( file.Seek ( -(int)sizeof(t_BaseDownInfo), CFile::end ) == (int)(file.GetLength() - sizeof(t_BaseDownInfo)) )

{

file.Write ( &m_BaseDownInfo, sizeof(t_BaseDownInfo) );

if ( file.Seek ( -GetDownloadInfoWholeSize(), CFile::end ) == int(file.GetLength() - GetDownloadInfoWholeSize()) )

{

file.Write ( m_pDownloadCellInfo, m_nThreadCount*sizeof(t_DownloadCellInfo) );

bRet = TRUE;

}

}

}

}

CATCH( CFileException, e )

{

e->Delete ();

bRet = FALSE;

}

END_CATCH

if ( HANDLE_IS_VALID ( file.m_hFile ) )

file.Close ();

if ( !bRet ) Log ( L_WARNING, "Save download info failed. %s", hwFormatMessage ( GetLastError() ) );

return bRet;

}

BOOL CDownloadMTR::HandleDownloadFinished(ENUM_DOWNLOAD_RESULT eDownloadResult)

{

CString csTempFileName;

CFileStatus fileStatus;

BOOL bRet = FALSE;

CFile file;

if ( eDownloadResult != ENUM_DOWNLOAD_RESULT_SUCCESS )

{

SaveDownloadInfo ();

goto Finished;

}

csTempFileName = GetTempFilePath ();

// 设置文件大小

if ( m_pDownloadPub_Info->Is_SupportResume() && m_pDownloadPub_Info->Get_FileTotalSize() > 0 )

{

TRY

{

file.Open ( csTempFileName, CFile::modeCreate|CFile::modeNoTruncate|CFile::modeReadWrite|CFile::typeBinary|CFile::shareDenyNone );

file.SetLength(m_pDownloadPub_Info->Get_FileTotalSize ());

bRet = TRUE;

}

CATCH( CFileException, e )

{

e->Delete ();

bRet = FALSE;

}

END_CATCH

if ( HANDLE_IS_VALID(file.m_hFile) )

file.Close ();

if ( !bRet )

{

Log ( L_WARNING, "Set [%s] length failed", csTempFileName );

eDownloadResult = ENUM_DOWNLOAD_RESULT_FAILED;

goto Finished;

}

}

if ( _access(csTempFileName,04) == 0 )

{

// 将文件改名

bRet = FALSE;

DeleteFile ( m_csSavePathFileName );

TRY

{

CFile::Rename ( csTempFileName, m_csSavePathFileName );

bRet = TRUE;

}

CATCH( CFileException, e )

{

e->Delete ();

bRet = FALSE;

}

END_CATCH

if ( !bRet )

{

Log ( L_WARNING, "Rename [%s] failed. %s", csTempFileName, hwFormatMessage(GetLastError()) );

eDownloadResult = ENUM_DOWNLOAD_RESULT_FAILED;

goto Finished;

}

// 设置文件属性，时间设置和服务器一致

bRet = FALSE;

if ( CFile::GetStatus(m_csSavePathFileName,fileStatus) )

{

fileStatus.m_mtime = m_pDownloadPub_Info->Get_TimeLastModified();

fileStatus.m_attribute = CFile::normal;

CFile::SetStatus ( m_csSavePathFileName, fileStatus );

bRet = TRUE;

}

if ( !bRet )

{

Log ( L_WARNING, "Set file [%s] status failed. %s", csTempFileName, hwFormatMessage(GetLastError()) );

eDownloadResult = ENUM_DOWNLOAD_RESULT_FAILED;

goto Finished;

}

}

Finished:

DownloadNotify ( -1, NOTIFY_TYPE_END_DOWNLOAD, (LPVOID)eDownloadResult, this );

return bRet;

}

BOOL CDownloadMTR::GetDownloadResult()

{

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

if ( !m_pDownloadPub_MTR[nIndex].Is_DownloadSuccess() )

return FALSE;

}

return TRUE;

}

//

// 下载信息是否有效

//

BOOL CDownloadMTR::DownloadInfoIsValid()

{

BOOL bValid = FALSE;

int nIndex = 0;

if ( !m_pDownloadCellInfo ) goto Invalid;

if ( m_BaseDownInfo.dwThreadCount < 1 || m_BaseDownInfo.dwThreadCount > MAX_DOWNLOAD_THREAD_COUNT )

goto Invalid;

for ( nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

if ( m_pDownloadCellInfo[nIndex].nWillDownloadSize > 0 )

{

bValid = TRUE;

break;

}

}

if ( !bValid ) goto Invalid;

return TRUE;

Invalid:

if ( m_pDownloadCellInfo )

memset ( m_pDownloadCellInfo, 0, m_nThreadCount*sizeof(t_DownloadCellInfo) );

memset ( &m_BaseDownInfo, 0, sizeof(t_BaseDownInfo) );

return FALSE;

}

//

// 找到剩余未下载的数量最大的那个对象编号

//

int CDownloadMTR::GetUndownloadMaxBytes( int &nUndownloadBytes )

{

nUndownloadBytes = 0;

int nMaxIndex = -1;

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

int nTempBytes = m_pDownloadPub_MTR[nIndex].GetUndownloadBytes ();

if ( nUndownloadBytes < nTempBytes )

{

nUndownloadBytes = nTempBytes;

nMaxIndex = nIndex;

}

}

return nMaxIndex;

}

//

// 编号为 nIndex 的对象调度任务，为下载任务最繁重的对象减轻负担

//

BOOL CDownloadMTR::AttemperDownloadTask(int nIndex)

{

ASSERT ( m_pDownloadPub_MTR && m_pDownloadCellInfo );

if ( m_nThreadCount <= 1 || m_pDownloadCellInfo[nIndex].nWillDownloadSize == -1 )

return FALSE;

int nUndownloadBytes = 0;

int nIndex_Heavy = GetUndownloadMaxBytes ( nUndownloadBytes );

if ( nIndex_Heavy == -1 || nIndex_Heavy == nIndex )

return FALSE;

if ( m_pDownloadPub_MTR[nIndex_Heavy].ThreadIsRunning() && nUndownloadBytes < 100*1024 )

return FALSE;

ASSERT ( nIndex_Heavy >= 0 && nIndex_Heavy < m_nThreadCount );

ASSERT ( m_pDownloadPub_MTR[nIndex_Heavy].Get_WillDownloadStartPos() == m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadStartPos );

DbgLog ( "下载对象.%d 帮 %d (%s) 减轻负担/n", nIndex, nIndex_Heavy, m_pDownloadPub_MTR[nIndex_Heavy].ThreadIsRunning()?"运行":"停止" );

// 给空闲下载对象分配新任务

m_pDownloadCellInfo[nIndex].nWillDownloadSize = ( m_pDownloadPub_MTR[nIndex_Heavy].ThreadIsRunning()?(nUndownloadBytes/2) : nUndownloadBytes );

m_pDownloadCellInfo[nIndex].nWillDownloadStartPos = m_pDownloadPub_MTR[nIndex_Heavy].Get_WillDownloadStartPos() +

m_pDownloadPub_MTR[nIndex_Heavy].Get_WillDownloadSize() - m_pDownloadCellInfo[nIndex].nWillDownloadSize;

m_pDownloadCellInfo[nIndex].nDownloadedSize = 0;

DbgLog ( "空闲下载对象.%d 分配新任务： %d(0x%08x) - %d(0x%08x) 共 %d(0x%08x)/n", nIndex, m_pDownloadCellInfo[nIndex].nWillDownloadStartPos, m_pDownloadCellInfo[nIndex].nWillDownloadStartPos,

m_pDownloadCellInfo[nIndex].nWillDownloadStartPos + m_pDownloadCellInfo[nIndex].nWillDownloadSize, m_pDownloadCellInfo[nIndex].nWillDownloadStartPos + m_pDownloadCellInfo[nIndex].nWillDownloadSize,

m_pDownloadCellInfo[nIndex].nWillDownloadSize, m_pDownloadCellInfo[nIndex].nWillDownloadSize );

// 启动空闲下载对象的下载任务

if ( m_pDownloadCellInfo[nIndex].nWillDownloadSize == 0 )

return FALSE;

m_pDownloadPub_MTR[nIndex].ResetVar ();

if ( !m_pDownloadPub_MTR[nIndex].Download ( m_pDownloadCellInfo[nIndex].nWillDownloadStartPos,

m_pDownloadCellInfo[nIndex].nWillDownloadSize, m_pDownloadCellInfo[nIndex].nDownloadedSize ) )

return FALSE;

// 减轻繁忙下载对象的任务

m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadSize -= m_pDownloadCellInfo[nIndex].nWillDownloadSize;

m_pDownloadPub_MTR[nIndex_Heavy].Set_WillDownloadSize ( m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadSize );

DbgLog ( "繁忙下载对象.%d 下载了 %d(0x%08x) 未完 %d(0x%08x) 字节，调整任务为： %d(0x%08x) - %d(0x%08x) 共 %d(0x%08x)/n",

nIndex_Heavy, m_pDownloadPub_MTR[nIndex_Heavy].Get_DownloadedSize(), m_pDownloadPub_MTR[nIndex_Heavy].Get_DownloadedSize(),

nUndownloadBytes, nUndownloadBytes,

m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadStartPos, m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadStartPos,

m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadStartPos + m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadSize, m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadStartPos + m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadSize,

m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadSize, m_pDownloadCellInfo[nIndex_Heavy].nWillDownloadSize );

return TRUE;

}

//

// 等待下载结束

//

ENUM_DOWNLOAD_RESULT CDownloadMTR::WaitForDownloadFinished()

{

ASSERT ( HANDLE_IS_VALID(m_hEvtEndModule) );

int nCount = m_nThreadCount + 1;

ENUM_DOWNLOAD_RESULT eDownloadResult = ENUM_DOWNLOAD_RESULT_FAILED;

HANDLE *lpHandles = new HANDLE[nCount];

if ( !lpHandles ) goto End;

while ( TRUE )

{

nCount = 0;

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

HANDLE hThread = m_pDownloadPub_MTR[nIndex].Get_Thread_Handle ();

if ( HANDLE_IS_VALID(hThread) )

lpHandles[nCount++] = hThread;

}

lpHandles[nCount++] = m_hEvtEndModule;

if ( nCount == 1 )

{

if ( Get_TotalDownloadedSize() >= m_pDownloadPub_Info->Get_FileTotalSize() )

{

ASSERT ( Get_TotalDownloadedSize() == m_pDownloadPub_Info->Get_FileTotalSize() );

eDownloadResult = ENUM_DOWNLOAD_RESULT_SUCCESS;

}

else

eDownloadResult = ENUM_DOWNLOAD_RESULT_FAILED;

goto End;

}

int nRet = (int)WaitForMultipleObjects ( nCount, lpHandles, FALSE, INFINITE ) - WAIT_OBJECT_0;

// 某下载对象完成任务了

if ( nRet >= 0 && nRet < nCount-1 )

{

nIndex = FindIndexByThreadHandle ( lpHandles[nRet] );

if ( ( nIndex >= 0 && nIndex < m_nThreadCount ) )

{

if ( !m_pDownloadPub_MTR[nIndex].Is_DownloadSuccess() ||

!AttemperDownloadTask ( nIndex ) )

{

m_pDownloadPub_MTR[nIndex].Clear_Thread_Handle ();

}

}

else

{

eDownloadResult = ENUM_DOWNLOAD_RESULT_CANCEL;

goto End;

}

}

// 模块结束

else

{

eDownloadResult = ENUM_DOWNLOAD_RESULT_CANCEL;

goto End;

}

}

End:

// 等待所有下载线程结束

if ( eDownloadResult != ENUM_DOWNLOAD_RESULT_SUCCESS )

{

nCount = 0;

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

HANDLE hThread = m_pDownloadPub_MTR[nIndex].Get_Thread_Handle ();

if ( HANDLE_IS_VALID(hThread) )

lpHandles[nCount++] = hThread;

}

WaitForMultipleObjects ( nCount, lpHandles, TRUE, 500*1000 );

}

if ( lpHandles ) delete[] lpHandles;

return eDownloadResult;

}

int CDownloadMTR::FindIndexByThreadHandle(HANDLE hThread)

{

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

HANDLE hThread_Temp = m_pDownloadPub_MTR[nIndex].Get_Thread_Handle ();

if ( HANDLE_IS_VALID(hThread_Temp) && hThread_Temp == hThread )

return nIndex;

}

return -1;

}

int CDownloadMTR::GetDownloadInfoWholeSize()

{

return ( sizeof(t_DownloadCellInfo)*m_nThreadCount + sizeof(t_BaseDownInfo) );

}

//

// 获取下载所消耗的时间（毫秒），可用来计算下载速度和推算剩余时间

//

DWORD CDownloadMTR::GetDownloadElapsedTime()

{

return (GetTickCount() - m_dwDownloadStartTime);

}

//

// 停止下载。将所有下载线程关闭，将下载对象删除，文件关闭

//

void CDownloadMTR::StopDownload()

{

if ( HANDLE_IS_VALID(m_hEvtEndModule) )

{

::SetEvent ( m_hEvtEndModule );

}

// 设置多线程下载使用的对象的参数

if ( m_pDownloadPub_MTR )

{

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

m_pDownloadPub_MTR[nIndex].StopDownload ();

}

}

if ( m_pDownloadPub_Info )

{

m_pDownloadPub_Info->StopDownload ();

}

if ( HANDLE_IS_VALID(m_hThread) )

{

WaitForThreadEnd ( m_hThread,100*1000 );

CLOSE_HANDLE ( m_hThread )

}

DeleteDownloadObjectAndDataMTR ();

DeleteDownloadObject_Info ();

CLOSE_HANDLE ( m_hEvtEndModule );

}

void CDownloadMTR::StandardSaveFileName ()

{

ASSERT ( m_csSavePath.GetLength() > 0 );

StandardizationPathBuffer ( m_csSavePath.GetBuffer(MAX_PATH), MAX_PATH );

m_csSavePath.ReleaseBuffer ();

MakeSureDirectory ( m_csSavePath );

char szOnlyFileName_NoExt_User[MAX_PATH] = {0};

char szExtensionName_User[MAX_PATH] = {0};

// 如果用户指定了新的保存文件名，就用新的。

if ( m_csSaveOnlyFileName.GetLength() > 0 )

{

CString csFileNameByURL = GetLocalFileNameByURL ( m_csDownloadURL );

if ( csFileNameByURL.CompareNoCase(m_csSaveOnlyFileName) != 0 )

{

PartFileAndExtensionName ( m_csSaveOnlyFileName, szOnlyFileName_NoExt_User, MAX_PATH, szExtensionName_User, MAX_PATH );

}

}

CString csExtensionName_Remote;

CString csFileName_Remote = m_pDownloadPub_Info->GetDownloadObjectFileName ( &csExtensionName_Remote );

if ( strlen(szOnlyFileName_NoExt_User) > 0 )

{

if ( strlen(szExtensionName_User) < 1 )

STRNCPY_CS ( szExtensionName_User, csExtensionName_Remote );

m_csSavePathFileName.Format ( "%s%s.%s", StandardizationFileForPathName(m_csSavePath,FALSE),

StandardizationFileForPathName(szOnlyFileName_NoExt_User,TRUE), StandardizationFileForPathName(szExtensionName_User,TRUE) );

}

else

{

m_csSavePathFileName.Format ( "%s%s", StandardizationFileForPathName(m_csSavePath,FALSE), StandardizationFileForPathName(csFileName_Remote,TRUE) );

}

}

//

// 根据 URL 来获取本地保存的文件名

//

CString CDownloadMTR::GetLocalFileNameByURL ( LPCTSTR lpszDownloadURL )

{

if ( !lpszDownloadURL || strlen(lpszDownloadURL) < 1 )

return "";

char szOnlyPath[MAX_PATH] = {0};

char szOnlyFileName[MAX_PATH] = {0};

if ( !PartFileAndPathByFullPath ( lpszDownloadURL, szOnlyFileName, MAX_PATH, szOnlyPath, MAX_PATH ) )

return "";

return szOnlyFileName;

}

//

// 获取文件大小

//

int CDownloadMTR::Get_FileTotaleSize()

{

if ( !m_pDownloadPub_Info ) return -1;

return m_pDownloadPub_Info->Get_FileTotalSize ();

}

//

// 获取已下载的字节数，包括以前下载的和本次下载的

//

int CDownloadMTR::Get_TotalDownloadedSize()

{

if ( !m_pDownloadPub_Info ) return -1;

int nTotalUndownloadBytes = 0;

for ( int nIndex=0; nIndex<m_nThreadCount; nIndex++ )

{

nTotalUndownloadBytes += m_pDownloadPub_MTR[nIndex].GetUndownloadBytes();

}

int nFileSize = m_pDownloadPub_Info->Get_FileTotalSize();

if ( nFileSize < 1 ) return -1;

// 文件大小减去未完成的，就是已下载的

return ( nFileSize - nTotalUndownloadBytes );

}

int CDownloadMTR::Get_TotalDownloadedSize_ThisTimes()

{

m_CSFor_DownloadedData.Lock ();

int nTotalDownloadedSize_ThisTimes = m_nTotalDownloadedSize_ThisTimes;

m_CSFor_DownloadedData.Unlock ();

return nTotalDownloadedSize_ThisTimes;

}