網路編程——斷點續傳和多線程下載模式)

 網路編程——斷點續傳和多線程下載模式  
  

概述

    在當今的網路時代，下載軟體是使用最為頻繁的軟體之一。幾年來，下載技術也在不停地發展。最原始的下載功能僅僅是個“下載”過程，即從WEB伺服器上連續地讀取檔案。其最大的問題是，由於網路的不穩定性，一旦串連斷開使得下載過程中斷，就不得不全部從頭再來一次。

    隨後，“斷點續傳”的概念就出來了，顧名思義，就是如果下載中斷，在重建立立串連後，跳過已經下載的部分，而只下載還沒有下載的部分。
無論“多線程下載”技術是否洪以容先生的發明，洪以容使得這項技術得到前所未有的關注是不爭的事實。在“網路螞蟻”軟體流行開後，許多下載軟體也都紛紛效仿，是否具?quot;多線程下載"技術、甚至能支援多少個下載線程都成了人們評測下載軟體的要素。"多線程下載"的基礎是WEB伺服器支援遠端隨機讀取，也即支援"斷點續傳"。這樣，在下載時可以把檔案分成若干部分，每一部分建立一個下載線程進行下載。

    現在，不要說編寫專門的下載軟體，在自己編寫的軟體中，加入下載功能有時也非常必要。如讓自己的軟體支援自動線上升級，或者在軟體中自動下載新的資料進行資料更新，這都是很有用、而且很實用的功能。本文的主題即怎樣編寫一個支援"斷點續傳"和"多線程"的下載模組。當然，下載的過程非常複雜，在一篇文章中難以全部闡明，所以，與下載過程關係不直接的部分基本上都忽略了，如異常處理和網路錯誤處理等，敬請各位讀者注意。我使用的開發環境是C++ Builder 5.0，使用其他開發環境或者程式設計語言的朋友請自行作適當修改。

HTTP協議簡介

    下載檔案是電腦與WEB伺服器互動的過程，它們互動的"語言"的專業名稱是協議。傳送檔案的協議有多種，最常用的是HTTP（超文字傳輸通訊協定 (HTTP)）和FTP（檔案傳送協議），我採用的是HTTP。

    HTTP協議最基本的命令只有三條：Get、Post和Head。Get從WEB伺服器請求一個特定的對象，比如HTML頁面或者一個檔案，WEB伺服器通過一個Socket串連發送此對象作為響應；Head命令使伺服器給出此對象的基本描述，比如對象的類型、大小和更新時間。Post命令用於向WEB伺服器發送資料，通常使把資訊發送給一個單獨的應用程式，經處理產生動態結果返回給瀏覽器。下載即是通過Get命令實現。

基本的下載過程

    編寫下載程式，可以直接使用Socket函數，但是這要求開發人員理解、熟悉TCP/IP協議。為了簡化Internet用戶端軟體的開發，Windows提供了一套WinInet API，對常用的網路通訊協定進行了封裝，把開發Internet軟體的門檻大大降低了。我們需要使用的WinInet API函數1所示，調用順序基本上是從上到下，其具體的函數原型請參考MSDN。

 在使用這些函數時，必須嚴格區分它們使用的控制代碼。這些控制代碼的類型是一樣的，都是HINTERNET，但是作用不同，這一點非常讓人迷惑。按照這些控制代碼的產生順序和調用關係，可以分為三個層級，下一級的控制代碼由上一級的控制代碼得到。

    InternetOpen是最先調用的函數，它返回的HINTERNET控制代碼層級最高，我習慣定義為hSession，即交談控制代碼。

    InternetConnect使用hSession控制代碼，返回的是http串連控制代碼，我把它定義為hConnect。

    HttpOpenRequest使用hConnect控制代碼，返回的控制代碼是http請求控制代碼，定義為hRequest。

    HttpSendRequest、HttpQueryInfo、InternetSetFilePointer和InternetReadFile都使用HttpOpenRequest返回的控制代碼，即hRequest。

    當這幾個控制代碼不再使用是，應該用函數InternetCloseHandle把它關閉，以釋放其佔用的資源。

    首先建立一個名為THttpGetThread、建立後自動掛起的線程模組，我希望線程在完成後自動銷毀，所以在建構函式中設定：

FreeOnTerminate = True; // 自動刪除

    並增加以下成員變數：

char Buffer[HTTPGET_BUFFER_MAX+4]; // 資料緩衝區
AnsiString FURL; // 下載對象的URL
AnsiString FOutFileName; // 儲存的路徑和名稱
HINTERNET FhSession; // 交談控制代碼
HINTERNET FhConnect; // http串連控制代碼
HINTERNET FhRequest; // http請求控制代碼
bool FSuccess; // 下載是否成功
int iFileHandle; // 輸出檔案的控制代碼

1、建立串連

    按照功能劃分，下載過程可以分為4部分，即建立串連、讀取待下載檔案的資訊並分析、下載檔案和釋放佔用的資源。建立串連的函數如下，其中ParseURL的作用是從下載URL地址中取得主機名稱和下載的檔案的WEB路徑，DoOnStatusText用於輸出當前的狀態：

//初始化下載環境
void THttpGetThread::StartHttpGet(void)
{
   AnsiString HostName,FileName;
   ParseURL(HostName, FileName);
   try
   {
      // 1.建立會話
      FhSession = InternetOpen("http-get-demo",
            INTERNET_OPEN_TYPE_PRECONFIG,
            NULL,NULL,
            0); // 同步方式
      if( FhSession==NULL)throw(Exception("Error：InterOpen"));
      DoOnStatusText("ok：InterOpen");
      // 2.建立串連
      FhConnect=InternetConnect(FhSession,
            HostName.c_str(),
            INTERNET_DEFAULT_HTTP_PORT,
            NULL,NULL,
            INTERNET_SERVICE_HTTP, 0, 0);
      if(FhConnect==NULL)throw(Exception("Error：InternetConnect"));
      DoOnStatusText("ok：InternetConnect");
      // 3.初始化下載請求
      const char *FAcceptTypes = "*/*";
      FhRequest = HttpOpenRequest(FhConnect,
            "GET", // 從伺服器擷取資料
            FileName.c_str(), // 想讀取的檔案的名稱
            "HTTP/1.1", // 使用的協議
            NULL,
            &FAcceptTypes,
            INTERNET_FLAG_RELOAD,
            0);
      if( FhRequest==NULL)throw(Exception("Error：HttpOpenRequest"));
      DoOnStatusText("ok：HttpOpenRequest");
      // 4.發送下載請求
      HttpSendRequest(FhRequest, NULL, 0, NULL, 0);
      DoOnStatusText("ok：HttpSendRequest");
   }catch(Exception &exception)
   {
      EndHttpGet(); // 關閉串連，釋放資源
      DoOnStatusText(exception.Message);
   }
}
// 從URL中提取主機名稱和下載檔案路徑
void THttpGetThread::ParseURL(AnsiString &HostName,AnsiString &FileName)
{
   AnsiString URL=FURL;
   int i=URL.Pos("http://");
   if(i>0)
   {
      URL.Delete(1, 7);
   }
   i=URL.Pos("/");
   HostName = URL.SubString(1, i-1);
   FileName = URL.SubString(i, URL.Length());
}

    可以看到，程式按照圖1中的順序，依次調用InternetOpen、InternetConnect、HttpOpenRequest函數得到3個相關的控制代碼，然後通過HttpSendRequest函數把下載的請求發送給WEB伺服器。

    InternetOpen的第一個參數是無關的，最後一個參數如果設定為INTERNET_FLAG_ASYNC，則將建立非同步串連，這很有實際意義，考慮到本文的複雜程度，我沒有採用。但是對於需要更高下載要求的讀者，強烈建議採用非同步方式。

    HttpOpenRequest開啟一個請求控制代碼，命令是"GET"，表示下載檔案，使用的協議是"HTTP/1.1"。

    另外一個需要注意的地方是HttpOpenRequest的參數FAcceptTypes，表示可以開啟的檔案類型，我設定為"*/*"表示可以開啟所有檔案類型，可以根據實際需要改變它的值。

2、讀取待下載的檔案的資訊並分析

    在發送請求後，可以使用HttpQueryInfo函數擷取檔案的有關資訊，或者取得伺服器的資訊以及伺服器支援的相關操作。對於下載程式，最常用的是傳遞HTTP_QUERY_CONTENT_LENGTH參數取得檔案的大小，即檔案包含的位元組數。模組如下所示：

// 取得待下載檔案的大小
int __fastcall THttpGetThread::GetWEBFileSize(void)
{
   try
   {
      DWORD BufLen=HTTPGET_BUFFER_MAX;
            DWORD dwIndex=0;
            bool RetQueryInfo=HttpQueryInfo(FhRequest,
            HTTP_QUERY_CONTENT_LENGTH,
            Buffer, &BufLen,
            &dwIndex);
      if( RetQueryInfo==false) throw(Exception("Error：HttpQueryInfo"));
      DoOnStatusText("ok：HttpQueryInfo");
      int FileSize=StrToInt(Buffer); // 檔案大小
      DoOnGetFileSize(FileSize);
   }catch(Exception &exception)
   {
      DoOnStatusText(exception.Message);
   }
   return FileSize;
}

    模組中的DoOnGetFileSize是發出取得檔案大小的事件。取得檔案大小後，對於採用多線程的下載程式，可以按照這個值進行合適的檔案分塊，確定每個檔案塊的起點和大小。

3、下載檔案的模組

    開始下載前，還應該先安排好怎樣儲存下載結果。方法很多，我直接採用了C++ Builder提供的檔案函數開啟一個檔案控制代碼。當然，也可以採用Windows本身的API，對於小檔案，全部緩衝到記憶體中也可以考慮。

// 開啟輸出檔案，以儲存下載的資料
DWORD THttpGetThread::OpenOutFile(void)
{
   try
   {
   if(FileExists(FOutFileName))
      DeleteFile(FOutFileName);
   iFileHandle=FileCreate(FOutFileName);
   if(iFileHandle==-1) throw(Exception("Error：FileCreate"));
   DoOnStatusText("ok:CreateFile");
   }catch(Exception &exception)
   {
      DoOnStatusText(exception.Message);
   }
   return 0;
}
// 執行下載過程
void THttpGetThread::DoHttpGet(void)
{
   DWORD dwCount=OpenOutFile();
   try
   {
      // 發出開始下載事件
      DoOnStatusText("StartGet：InternetReadFile");
      // 讀取資料
      DWORD dwRequest; // 請求下載的位元組數
      DWORD dwRead; // 實際讀出的位元組數
      dwRequest=HTTPGET_BUFFER_MAX;
      while(true)
      {
         Application->ProcessMessages();
         bool ReadReturn = InternetReadFile(FhRequest,
              (LPVOID)Buffer,
              dwRequest,
              &dwRead);
         if(!ReadReturn)break;
         if(dwRead==0)break;
         // 儲存資料
         Buffer[dwRead]='';
         FileWrite(iFileHandle, Buffer, dwRead);
         dwCount = dwCount + dwRead;
         // 發出下載進程事件
         DoOnProgress(dwCount);
      }
      Fsuccess=true;
   }catch(Exception &exception)
   {
      Fsuccess=false;
      DoOnStatusText(exception.Message);
   }
   FileClose(iFileHandle);
   DoOnStatusText("End：InternetReadFile");
}

    下載過程並不複雜，與讀取本地檔案一樣，執行一個簡單的迴圈。當然，如此方便的編程還是得益於微軟對網路通訊協定的封裝。

4、釋放佔用的資源

    這個過程很簡單，按照產生各個控制代碼的相反的順序調用InternetCloseHandle函數即可。

void THttpGetThread::EndHttpGet(void)
{
   if(FConnected)
   {
      DoOnStatusText("Closing:InternetConnect");
      try
      {
         InternetCloseHandle(FhRequest);
         InternetCloseHandle(FhConnect);
         InternetCloseHandle(FhSession);
      }catch(...){}
      FhSession=NULL;
      FhConnect=NULL;
      FhRequest=NULL;
      FConnected=false;
      DoOnStatusText("Closed:InternetConnect");
   }
}

    我覺得，在釋放控制代碼後，把變數設定為NULL是一種良好的編程習慣。在這個樣本中，還出於如果下載失敗，重新進行下載時需要再次利用這些控制代碼變數的考慮。

5、功能模組的調用

    這些模組的調用可以安排線上程對象的Execute方法中，如下所示：

void __fastcall THttpGetThread::Execute()
{
   FrepeatCount=5;
   for(int i=0;i<FRepeatCount;i++)
   {
      StartHttpGet();
      GetWEBFileSize();
      DoHttpGet();
      EndHttpGet();
      if(FSuccess)break;
   }
   // 發出下載完成事件
   if(FSuccess)DoOnComplete();
   else DoOnError();
}

    這裡執行了一個迴圈，即如果產生了錯誤自動重新進行下載，實際編程中，重複次數可以作為參數自行設定。

實現斷點續傳功能

    在基本下載的代碼上實現斷點續傳功能並不是很複雜，主要的問題有兩點：

1、檢查本地的下載資訊，確定已經下載的位元組數。所以應該對開啟輸出檔案的函數作適當修改。我們可以建立一個輔助檔案儲存下載的資訊，如已經下載的位元組數等。我處理得較為簡單，先檢查輸出檔案是否存在，如果存在，再得到其大小，並以此作為已經下載的部分。由於Windows沒有直接取得檔案大小的API，我編寫了GetFileSize函數用於取得檔案大小。注意，與前面相同的代碼被省略了。

DWORD THttpGetThread::OpenOutFile(void)
{
   ……
   if(FileExists(FOutFileName))
   {
      DWORD dwCount=GetFileSize(FOutFileName);
      if(dwCount>0)
      {
         iFileHandle=FileOpen(FOutFileName,fmOpenWrite);
         FileSeek(iFileHandle,0,2); // 移動檔案指標到末尾
         if(iFileHandle==-1) throw(Exception("Error：FileCreate"));
         DoOnStatusText("ok:OpenFile");
         return dwCount;
      }
      DeleteFile(FOutFileName);
   }
   ……
}

2、在開始下載檔案（即執行InternetReadFile函數）之前，先調整WEB上的檔案指標。這就要求WEB伺服器支援隨機讀取檔案的操作，有些伺服器對此作了限制，所以應該判斷這種可能性。對DoHttpGet模組的修改如下，同樣省略了相同的代碼：

void THttpGetThread::DoHttpGet(void)
{
   DWORD dwCount=OpenOutFile();
   if(dwCount>0) // 調整檔案指標
   {
      dwStart = dwStart + dwCount;
      if(!SetFilePointer()) // 伺服器不支援操作
      {
         // 清除輸出檔案
         FileSeek(iFileHandle,0,0); // 移動檔案指標到頭部
      }
   }
   ……
}

多線程下載

    要實現多線程下載，最主要的問題是下載線程的建立和管理，已經下載完成後檔案的各個部分的準確合并，同時，下載線程也要作必要的修改。

1、下載線程的修改

    為了適應多線程程式，我在下載線程加入如下成員變數：

int FIndex; // 線上程數組中的索引
DWORD dwStart; // 下載開始的位置
DWORD dwTotal; // 需要下載的位元組數
DWORD FGetBytes; // 下載的總位元組數

    並加入如下屬性值：

__property AnsiString URL = { read=FURL, write=FURL };
__property AnsiString OutFileName = { read=FOutFileName, write=FOutFileName};
__property bool Successed = { read=FSuccess};
__property int Index = { read=FIndex, write=FIndex};
__property DWORD StartPostion = { read=dwStart, write=dwStart};
__property DWORD GetBytes = { read=dwTotal, write=dwTotal};
__property TOnHttpCompelete OnComplete = { read=FOnComplete, write=FOnComplete };

    同時，在下載過程DoHttpGet中增加如下處理，

void THttpGetThread::DoHttpGet(void)
{
   ……
   try
   {
      ……
      while(true)
      {
         Application->ProcessMessages();
         // 修正需要下載的位元組數，使得dwRequest + dwCount <dwTotal;
         if(dwTotal>0) // dwTotal=0表示下載到檔案結束
         {
            if(dwRequest+dwCount>dwTotal)
            dwRequest=dwTotal-dwCount;
         }
         ……
         if(dwTotal>0) // dwTotal <=0表示下載到檔案結束
         {
            if(dwCount>=dwTotal)break;
         }
      }
   }
   ……
   if(dwCount==dwTotal)FSuccess=true;
}

2、建立多線程下載組件

    我先建立了以TComponent為基類、名為THttpGetEx的組件模組，並增加以下成員變數：

// 內部變數
THttpGetThread **HttpThreads; // 儲存建立的線程
AnsiString *OutTmpFiles; // 儲存結果檔案各個部分的臨時檔案
bool *FSuccesss; // 儲存各個線程的下載結果
// 以下是屬性變數
int FHttpThreadCount; // 使用的線程個數
AnsiString FURL;
AnsiString FOutFileName;

    各個變數的用途都如代碼注釋，其中的FSuccess的作用比較特別，下文會再加以詳細解釋。因為線程的運行具有無法復原性，而組件可能會連續地下載不同的檔案，所以下載線程只能動態建立，使用後隨即銷毀。建立線程的模組如下，其中GetSystemTemp函數取得系統的臨時檔案夾，OnThreadComplete是線程下載完成後的事件，其代碼在其後介紹：

// 分配資源
void THttpGetEx::AssignResource(void)
{
   FSuccesss=new bool[FHttpThreadCount];
   for(int i=0;i<FHttpThreadCount;i++)
      FSuccesss[i]=false;
   OutTmpFiles = new AnsiString[FHttpThreadCount];
   AnsiString ShortName=ExtractFileName(FOutFileName);
   AnsiString Path=GetSystemTemp();
   for(int i=0;i<FHttpThreadCount;i++)
      OutTmpFiles[i]=Path+ShortName+"-"+IntToStr(i)+".hpt";
   HttpThreads = new THttpGetThread *[FHttpThreadCount];
}
// 建立一個下載線程
THttpGetThread * THttpGetEx::CreateHttpThread(void)
{
   THttpGetThread *HttpThread=new THttpGetThread(this);
   HttpThread->URL=FURL;
   …… // 初始化事件
   HttpThread->OnComplete=OnThreadComplete; // 線程下載完成事件
   return HttpThread;
}
// 建立下載線程數組
void THttpGetEx::CreateHttpThreads(void)
{
   AssignResource();
   // 取得檔案大小，以決定各個線程下載的起始位置
   THttpGetThread *HttpThread=CreateHttpThread();
   HttpThreads[FHttpThreadCount-1]=HttpThread;
   int FileSize=HttpThread->GetWEBFileSize();
   // 把檔案分成FHttpThreadCount塊
   int AvgSize=FileSize/FHttpThreadCount;
   int *Starts= new int[FHttpThreadCount];
   int *Bytes = new int[FHttpThreadCount];
   for(int i=0;i<FHttpThreadCount;i++)
   {
      Starts[i]=i*AvgSize;
      Bytes[i] =AvgSize;
   }
   // 修正最後一塊的大小
   Bytes[FHttpThreadCount-1]=AvgSize+(FileSize-AvgSize*FHttpThreadCount);
   // 檢查伺服器是否支援斷點續傳
   HttpThread->StartPostion=Starts[FHttpThreadCount-1];
   HttpThread->GetBytes=Bytes[FHttpThreadCount-1];
   bool CanMulti=HttpThread->SetFilePointer();
   if(CanMulti==false) // 不支援，直接下載
   {
      FHttpThreadCount=1;
      HttpThread->StartPostion=0;
      HttpThread->GetBytes=FileSize;
      HttpThread->Index=0;
      HttpThread->OutFileName=OutTmpFiles[0];
   }else
   {
      HttpThread->OutFileName=OutTmpFiles[FHttpThreadCount-1];
      HttpThread->Index=FHttpThreadCount-1;
      // 支援斷點續傳，建立多個線程
      for(int i=0;i<FHttpThreadCount-1;i++)
      {
         HttpThread=CreateHttpThread();
         HttpThread->StartPostion=Starts[i];
         HttpThread->GetBytes=Bytes[i];
         HttpThread->OutFileName=OutTmpFiles[i];
         HttpThread->Index=i;
         HttpThreads[i]=HttpThread;
      }
   }
   // 刪除臨時變數
   delete Starts;
   delete Bytes;
}

    下載檔案的下載的函數如下：

void __fastcall THttpGetEx::DownLoadFile(void)
{
   CreateHttpThreads();
   THttpGetThread *HttpThread;
   for(int i=0;i<FHttpThreadCount;i++)
   {
      HttpThread=HttpThreads[i];
      HttpThread->Resume();
   }
}

    線程下載完成後，會發出OnThreadComplete事件，在這個事件中判斷是否所有下載線程都已經完成，如果是，則合并檔案的各個部分。應該注意，這裡有一個線程同步的問題，否則幾個線程同時產生這個事件時，會互相衝突，結果也會混亂。同步的方法很多，我的方法是建立線程互斥對象。

const char *MutexToThread="http-get-thread-mutex";
void __fastcall THttpGetEx::OnThreadComplete(TObject *Sender, int Index)
{
   // 建立互斥對象
   HANDLE hMutex= CreateMutex(NULL,FALSE,MutexToThread);
   DWORD Err=GetLastError();
   if(Err==ERROR_ALREADY_EXISTS) // 已經存在,等待
   {
      WaitForSingleObject(hMutex,INFINITE);//8000L);
      hMutex= CreateMutex(NULL,FALSE,MutexToThread);
   }
   // 當一個線程結束時，檢查是否全部認為完成
   FSuccesss[Index]=true;
   bool S=true;
   for(int i=0;i<FHttpThreadCount;i++)
   {
      S = S && FSuccesss[i];
   }
   ReleaseMutex(hMutex);
   if(S)// 下載完成，合并檔案的各個部分
   {
      // 1. 複製第一部分
      CopyFile(OutTmpFiles[0].c_str(),FOutFileName.c_str(),false);
      // 添加其他部分
      int hD=FileOpen(FOutFileName,fmOpenWrite);
      FileSeek(hD,0,2); // 移動檔案指標到末尾
      if(hD==-1)
      {
         DoOnError();
         return;
      }
      const int BufSize=1024*4;
      char Buf[BufSize+4];
      int Reads;
      for(int i=1;i<FHttpThreadCount;i++)
      {
         int hS=FileOpen(OutTmpFiles[i],fmOpenRead);
         // 複製資料
         Reads=FileRead(hS,(void *)Buf,BufSize);
         while(Reads>0)
         {
            FileWrite(hD,(void *)Buf,Reads);
            Reads=FileRead(hS,(void *)Buf,BufSize);
         }
         FileClose(hS);
      }
      FileClose(hD);
   }
}

結語

    到此，多線程下載的關鍵區段就介紹完了。但是在實際應用時，還有許多應該考慮的因素，如網路速度、斷線等等都是必須考慮的。當然還有一些細節上的考慮，但是限於篇幅，就難以一一寫明了。如果讀者朋友能夠參照本文編寫出自己滿意的下載程式，我也就非常欣慰了。我也非常希望讀者能由此與我互相學習，共同進步。