编程语言
首页 > 编程语言> > vc++ 实现多线程断点续传

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

作者:互联网

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

结合本人的FTP类,http类,实现多线程断点续传

 

 

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

#include "stdafx.h"
#include "downtest.h"
#include "DownloadMTR.h"
#include

#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

 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 ()

 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;
}


标签:Info,断点续传,return,pDownloadCellInfo,int,pDownloadPub,c++,多线程,nIndex
来源: https://blog.51cto.com/u_9634496/2732210