支持原創

現代系統通常提供異步接口，允許應用向系統提交請求，然后在系統處理請求時應用可以繼續處理自己的事情。Grand Central Dispatch正是基于這個基本行為而設計，允許你提交請求，并通過block和dispatch queue報告結果。

dispatch source是基礎數據類型，協調特定底層系統事件的處理。Grand Central Dispatch支持以下dispatch source：

• Timer dispatch source：定期產生通知

• Signal dispatch source：UNIX信號到達時產生通知
• Descriptor dispatch source：各種文件和socket操作的通知
• 數據可讀
• 數據可寫
• 文件在文件系統中被刪除、移動、重命名
• 文件元數據信息改變

Process dispatch source：進程相關的事件通知

• 當進程退出時

• 當進程發起fork或exec等調用
• 信號被遞送到進程
• Mach port dispatch source：Mach相關事件的通知
• Custom dispatch source：你自己定義并自己觸發

Dispatch source替代了異步回調函數，來處理系統相關的事件。當你配置一個dispatch source時，你指定要監測的事件、dispatch queue、以及處理事件的代碼(block或函數)。當事件發生時，dispatch source會提交你的block或函數到指定的queue去執行

和手工提交到queue的任務不同，dispatch source為應用提供連續的事件源。除非你顯式地取消，dispatch source會一直保留與dispatch queue的關聯。只要相應的事件發生，就會提交關聯的代碼到dispatch queue去執行。

為了防止事件積壓到dispatch queue，dispatch source實現了事件合并機制。如果新事件在上一個事件處理器出列并執行之前到達，dispatch source會將新舊事件的數據合并。根據事件類型的不同，合并操作可能會替換舊事件，或者更新舊事件的信息。

創建Dispatch Source

創建dispatch source需要同時創建事件源和dispatch source本身。事件源是處理事件所需要的native數據結構，例如基于描述符的dispatch source，你需要打開描述符;基于進程的事件，你需要獲得目標程序的進程ID。

然后可以如下創建相應的dispatch source：

使用 dispatch_source_create 函數創建dispatch source
配置dispatch source：
為dispatch source設置一個事件處理器
對于定時器源，使用 dispatch_source_set_timer 函數設置定時器信息

為dispatch source賦予一個取消處理器(可選)調用 dispatch_resume 函數開始處理事件由于dispatch source必須進行額外的配置才能被使用，dispatch_source_create函數返回的dispatch source將處于掛起狀態。此時dispatch source會接收事件，但是不會進行處理。這時候你可以安裝事件處理器，并執行額外的配置。

編寫和安裝一個事件處理器

你需要定義一個事件處理器來處理事件，可以是函數或block對象，并使用 dispatch_source_set_event_handler 或 dispatch_source_set_event_handler_f 安裝事件處理器。事件到達時，dispatch source會提交你的事件處理器到指定的dispatch queue，由queue執行事件處理器。

事件處理器的代碼負責處理所有到達的事件。如果事件處理器已經在queue中并等待處理已經到達的事件，如果此時又來了一個新事件，dispatch source會合并這兩個事件。事件處理器通常只能看到最新事件的信息，不過某些類型的dispatch source也能獲得已經發生以及合并的事件信息。

如果事件處理器已經開始執行，一個或多個新事件到達，dispatch source會保留這些事件，直到前面的事件處理器完成執行。然后以新事件再次提交處理器到queue。

函數事件處理器有一個context指針指向dispatch source對象，沒有返回值。Block事件處理器沒有參數，也沒有返回值。

// Block-based event handler 
void (^dispatch_block_t)(void)

// Function-based event handler 
void (dispatch_function_t)(void ) 

在事件處理器中，你可以從dispatch source中獲得事件的信息，函數處理器可以直接使用參數指針，Block則必須自己捕獲到dispatch source指針，一般block定義時會自動捕獲到外部定義的所有變量。

disatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, 
myDescriptor, 0, myQueue); 
dispatch_source_set_event_handler(source, ^{ 
// Get some data from the source variable, which is captured 
// from the parent context. 
size_t estimated = dispatch_source_get_data(source);

// Continue reading the descriptor… 
}); 
dispatch_resume(source); 

Block捕獲外部變量允許更大的靈活性和動態性。當然，在Block中這些變量默認是只讀的，雖然可以使用__block來修改捕獲的變量，但是你最好不要在事件處理器中這樣做。因為Dispatch source異步執行事件處理器，當事件處理器修改原始外部變量時，有可能這些變量已經不存在了。

下面是事件處理器能夠獲得的事件信息：

• 函數 描述
  dispatch_source_get_handle這個函數返回dispatch source管理的底層系統數據類型。

• 對于描述符dispatch source，函數返回一個int，表示關聯的描述符
• 對于信號dispatch source，函數返回一個int，表示最新事件的信號數值
• 對于進程dispatch source，函數返回一個pid_t數據結構，表示被監控的進程
• 對于Mach port dispatch source，函數返回一個 mach_port_t 數據結構
• 對于其它dispatch source，函數返回的值未定義
  dispatch_source_get_data這個函數返回事件關聯的所有未決數據。
• 對于從文件中讀取數據的描述符dispatch source，這個函數返回可以讀取的字節數
• 對于向文件中寫入數據的描述符dispatch source，如果可以寫入，則返回正數值
• 對于監控文件系統活動的描述符dispatch source，函數返回一個常量，表示發生的事件類型，參考 dispatch_source_vnode_flags_t枚舉類型
• 對于進程dispatch source，函數返回一個常量，表示發生的事件類型，參考 dispatch_source_proc_flags_t 枚舉類型
• 對于Mach port dispatch source，函數返回一個常量，表示發生的事件類型，參考dispatch_source_machport_flags_t 枚舉類型
• 對于自定義dispatch source，函數返回從現有數據創建的新數據，以及傳遞給 dispatch_source_merge_data 函數的新數據。
  dispatch_source_get_mask這個函數返回用來創建dispatch source的事件標志
• 對于進程dispatch source，函數返回dispatch source接收到的事件掩碼，參考dispatch_source_proc_flags_t 枚舉類型
• 對于發送權利的Mach port dispatch source，函數返回期望事件的掩碼，參考dispatch_source_mach_send_flags_t 枚舉類型
• 對于自定義 “或” 的dispatch source，函數返回用來合并數據值的掩碼。

安裝一個取消處理器

取消處理器在dispatch soruce釋放之前執行清理工作。多數類型的dispatch source不需要取消處理器，除非你對dispatch source有自定義行為需要在釋放時執行。但是使用描述符或Mach port的dispatch source必須設置取消處理器，用來關閉描述符或釋放Mach port。否則可能導致微妙的bug，這些結構體會被系統其它部分或你的應用在不經意間重用。

你可以在任何時候安裝取消處理器，但通常我們在創建dispatch source時就會安裝取消處理器。使用 dispatch_source_set_cancel_handler 或 dispatch_source_set_cancel_handler_f函數來設置取消處理器。

下面取消處理器關閉描述符：

dispatch_source_set_cancel_handler(mySource, ^{ 
close(fd); // Close a file descriptor opened earlier. 
}); 

修改目標Queue

在創建dispatch source時可以指定一個queue，用來執行事件處理器和取消處理器。不過你也可以使用 dispatch_set_target_queue 函數在任何時候修改目標queue。修改queue可以改變執行dispatch source事件的優先級。

修改dispatch source的目標queue是異步操作，dispatch source會盡可能快地完成這個修改。如果事件處理器已經進入queue并等待處理，它會繼續在原來的Queue中執行。隨后到達的所有事件的處理器都會在后面修改的queue中執行。

關聯自定義數據到dispatch source

和Grand Central Dispatch的其它類型一樣，你可以使用 dispatch_set_context 函數關聯自定義數據到dispatch source。使用context指針存儲事件處理器需要的任何數據。如果你在context指針中存儲了數據，你就應該安裝一個取消處理器，在dispatch source不再需要時釋放這些context自定義數據。

如果你使用block實現事件處理器，你也可以捕獲本地變量，并在Block中使用。雖然這樣也可以代替context指針，但是你應該明智地使用Block捕獲變量。因為dispatch source長時間存在于應用中，Block捕獲指針變量時必須非常小心，因為指針指向的數據可能會被釋放，因此需要復制數據或retain。不管使用哪種方法，你都應該提供一個取消處理器，在最后釋放這些數據。

Dispatch Source的內存管理

Dispatch Source也是引用計數的數據類型，初始計數為1，可以使用dispatch_retain和 dispatch_release 函數來增加和減少引用計數。引用計數到達0時，系統自動釋放dispatch source數據結構。

dispatch source的所有權可以由dispatch source內部或外部進行管理。外部所有權時，另一個對象擁有dispatch source，并負責在不需要時釋放它。內部所有權時，dispatch source自己擁有自己，并負責在適當的時候釋放自己。雖然外部所有權很常用，當你希望創建自主dispatch source，并讓它自己管理自己的行為時，可以使用內部所有權。例如dispatch source應用單一全局事件時，可以讓它自己處理該事件，并立即退出。

Dispatch Source示例

創建一個定時器

定時器dispatch source定時產生事件，可以用來發起定時執行的任務，如游戲或其它圖形應用，可以使用定時器來更新屏幕或動畫。你也可以設置定時器，并在固定間隔事件中檢查服務器的新信息。

所有定時器dispatch source都是間隔定時器，一旦創建，會按你指定的間隔定期遞送事件。你需要為定時器dispatch source指定一個期望的定時器事件精度，也就是leeway值，讓系統能夠靈活地管理電源并喚醒內核。例如系統可以使用leeway值來提前或延遲觸發定時器，使其更好地與其它系統事件結合。創建自己的定時器時，你應該盡量指定一個leeway值。

就算你指定leeway值為0，也不要期望定時器能夠按照精確的納秒來觸發事件。系統會盡可能地滿足你的需求，但是無法保證完全精確的觸發時間。

當計算機睡眠時，定時器dispatch source會被掛起，稍后系統喚醒時，定時器dispatch source也會自動喚醒。根據你提供的配置，暫停定時器可能會影響定時器下一次的觸發。如果定時器dispatch source使用 dispatch_time 函數或DISPATCH_TIME_NOW 常量設置，定時器dispatch source會使用系統默認時鐘來確定何時觸發，但是默認時鐘在計算機睡眠時不會繼續。

如果你使用dispatch_walltime函數來設置定時器dispatch source，則定時器會根據掛鐘時間來跟蹤，這種定時器比較適合觸發間隔相對比較大的場合，可以防止定時器觸發間隔出現太大的誤差。

下面是定時器dispatch source的一個例子，每30秒觸發一次，leeway值為1，因為間隔相對較大，使用 dispatch_walltime 來創建定時器。定時器會立即觸發第一次，隨后每30秒觸發一次。MyPeriodicTask 和 MyStoreTimer 是自定義函數，用于實現定時器的行為，并存儲定時器到應用的數據結構。

dispatch_source_t CreateDispatchTimer(uint64_t interval, 
uint64_t leeway, 
dispatch_queue_t queue, 
dispatch_block_t block) 
{ 
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 
0, 0, queue); 
if (timer) 
{ 
dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), interval, leeway); 
dispatch_source_set_event_handler(timer, block); 
dispatch_resume(timer); 
} 
return timer; 
}

void MyCreateTimer() 
{ 
dispatch_source_t aTimer = CreateDispatchTimer(30ull * NSEC_PER_SEC, 
1ull * NSEC_PER_SEC, 
dispatch_get_main_queue(), 
^{ MyPeriodicTask(); });

// Store it somewhere for later use. 
if (aTimer) 
{ 
MyStoreTimer(aTimer); 
} 
} 

雖然定時器dispatch source是接收時間事件的主要方法，你還可以使用其它選擇。如果想在指定時間間隔后執行一個block，可以使用 dispatch_after 或 dispatch_after_f函數。這兩個函數非常類似于dispatch_async，但是只允許你指定一個時間值，時間一到就自動提交block到queue中執行，時間值可以指定為相對或絕對時間。

從描述符中讀取數據

要從文件或socket中讀取數據，需要打開文件或socket，并創建一個 DISPATCH_SOURCE_TYPE_READ 類型的dispatch source。你指定的事件處理器必須能夠讀取和處理描述符中的內容。對于文件，需要讀取文件數據，并為應用創建適當的數據結構;對于網絡socket，需要處理最新接收到的網絡數據。

讀取數據時，你總是應該配置描述符使用非阻塞操作，雖然你可以使用dispatch_source_get_data 函數查看當前有多少數據可讀，但在你調用它和實際讀取數據之間，可用的數據數量可能會發生變化。如果底層文件被截斷，或發生網絡錯誤，從描述符中讀取會阻塞當前線程，停止在事件處理器中間并阻止dispatch queue去執行其它任務。對于串行queue，這樣還可能會死鎖，即使是并發queue，也會減少queue能夠執行的任務數量。

下面例子配置dispatch source從文件中讀取數據，事件處理器讀取指定文件的全部內容到緩沖區，并調用一個自定義函數來處理這些數據。調用方可以使用返回的dispatch source在讀取操作完成之后，來取消這個事件。為了確保dispatch queue不會阻塞，這里使用了fcntl函數，配置文件描述符執行非阻塞操作。dispatch source安裝了取消處理器，確保最后關閉了文件描述符。

dispatch_source_t ProcessContentsOfFile(const char* filename) 
{ 
// Prepare the file for reading. 
int fd = open(filename, O_RDONLY); 
if (fd == -1) 
return NULL; 
fcntl(fd, F_SETFL, O_NONBLOCK); // Avoid blocking the read operation

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
dispatch_source_t readSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, 
fd, 0, queue); 
if (!readSource) 
{ 
close(fd); 
return NULL; 
}

// Install the event handler 
dispatch_source_set_event_handler(readSource, ^{ 
size_t estimated = dispatch_source_get_data(readSource) + 1; 
// Read the data into a text buffer. 
char* buffer = (char*)malloc(estimated); 
if (buffer) 
{ 
ssize_t actual = read(fd, buffer, (estimated)); 
Boolean done = MyProcessFileData(buffer, actual); // Process the data.

     // Release the buffer when done. 
     free(buffer); 

     // If there is no more data, cancel the source. 
     if (done) 
        dispatch_source_cancel(readSource); 
  } 
}); 
// Install the cancellation handler 
dispatch_source_set_cancel_handler(readSource, ^{close(fd);});

// Start reading the file. 
dispatch_resume(readSource); 
return readSource; 
} 

在這個例子中，自定義的 MyProcessFileData 函數確定讀取到足夠的數據，返回YES告訴dispatch source讀取已經完成，可以取消任務。通常讀取描述符的dispatch source在還有數據可讀時，會重復調度事件處理器。如果socket連接關閉或到達文件末尾，dispatch source自動停止調度事件處理器。如果你自己確定不再需要dispatch source，也可以手動取消它。

向描述符寫入數據

向文件或socket寫入數據非常類似于讀取數據，配置描述符為寫入操作后，創建一個DISPATCH_SOURCE_TYPE_WRITE類型的dispatch source，創建好之后，系統會調用事件處理器，讓它開始向文件或socket寫入數據。當你完成寫入后，使用 dispatch_source_cancel 函數取消dispatch source。

寫入數據也應該配置文件描述符使用非阻塞操作，雖然 dispatch_source_get_data 函數可以查看當前有多少可用寫入空間，但這個值只是建議性的，而且在你執行寫入操作時可能會發生變化。如果發生錯誤，寫入數據到阻塞描述符，也會使事件處理器停止在執行中途，并阻止dispatch queue執行其它任務。串行queue會產生死鎖，并發queue則會減少能夠執行的任務數量。

下面是使用dispatch source寫入數據到文件的例子，創建文件后，函數傳遞文件描述符到事件處理器。MyGetData函數負責提供要寫入的數據，在數據寫入到文件之后，事件處理器取消dispatch source，阻止再次調用。此時dispatch source的擁有者需負責釋放dispatch source。

dispatch_source_t WriteDataToFile(const char* filename) 
{ 
int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 
(S_IRUSR | S_IWUSR | S_ISUID | S_ISGID)); 
if (fd == -1) 
return NULL; 
fcntl(fd, F_SETFL); // Block during the write.

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
dispatch_source_t writeSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE, 
                        fd, 0, queue); 
if (!writeSource) 
{ 
    close(fd); 
    return NULL; 
} 

dispatch_source_set_event_handler(writeSource, ^{ 
    size_t bufferSize = MyGetDataSize(); 
    void* buffer = malloc(bufferSize); 

    size_t actual = MyGetData(buffer, bufferSize); 
    write(fd, buffer, actual); 

    free(buffer); 

    // Cancel and release the dispatch source when done. 
    dispatch_source_cancel(writeSource); 
}); 

dispatch_source_set_cancel_handler(writeSource, ^{close(fd);}); 
dispatch_resume(writeSource); 
return (writeSource); 
} 

監控文件系統對象

如果需要監控文件系統對象的變化，可以設置一個 DISPATCH_SOURCE_TYPE_VNODE 類型的dispatch source，你可以從這個dispatch source中接收文件刪除、寫入、重命名等通知。你還可以得到文件的特定元數據信息變化通知。

在dispatch source正在處理事件時，dispatch source中指定的文件描述符必須保持打開狀態。

下面例子監控一個文件的文件名變化，并在文件名變化時執行一些操作(自定義的 MyUpdateFileName 函數)。由于文件描述符專門為dispatch source打開，dispatch source安裝了取消處理器來關閉文件描述符。這個例子中的文件描述符關聯到底層的文件系統對象，因此同一個dispatch source可以用來檢測多次文件名變化。

dispatch_source_t MonitorNameChangesToFile(const char* filename) 
{ 
int fd = open(filename, O_EVTONLY); 
if (fd == -1) 
return NULL;

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_VNODE, 
fd, DISPATCH_VNODE_RENAME, queue); 
if (source) 
{ 
// Copy the filename for later use. 
int length = strlen(filename); 
char* newString = (char*)malloc(length + 1); 
newString = strcpy(newString, filename); 
dispatch_set_context(source, newString);

  // Install the event handler to process the name change 
  dispatch_source_set_event_handler(source, ^{ 
        const char*  oldFilename = (char*)dispatch_get_context(source); 
        MyUpdateFileName(oldFilename, fd); 
  }); 

  // Install a cancellation handler to free the descriptor 
  // and the stored string. 
  dispatch_source_set_cancel_handler(source, ^{ 
      char* fileStr = (char*)dispatch_get_context(source); 
      free(fileStr); 
      close(fd); 
  }); 

  // Start processing events. 
  dispatch_resume(source); 
} 
else 
close(fd);

return source; 
} 

監測信號

應用可以接收許多不同類型的信號，如不可恢復的錯誤(非法指令)、或重要信息的通知(如子進程退出)。傳統編程中，應用使用 sigaction 函數安裝信號處理器函數，信號到達時同步處理信號。如果你只是想信號到達時得到通知，并不想實際地處理該信號，可以使用信號dispatch source來異步處理信號。

信號dispatch source不能替代 sigaction 函數提供的同步信號處理機制。同步信號處理器可以捕獲一個信號，并阻止它中止應用。而信號dispatch source只允許你監測信號的到達。此外，你不能使用信號dispatch source獲取所有類型的信號，如SIGILL, SIGBUS, SIGSEGV信號。

由于信號dispatch source在dispatch queue中異步執行，它沒有同步信號處理器的一些限制。例如信號dispatch source的事件處理器可以調用任何函數。靈活性增大的代價是，信號到達和dispatch source事件處理器被調用的延遲可能會增大。

下面例子配置信號dispatch source來處理SIGHUP信號，事件處理器調用 MyProcessSIGHUP 函數，用來處理信號。

void InstallSignalHandler() 
{ 
// Make sure the signal does not terminate the application. 
signal(SIGHUP, SIG_IGN);

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGHUP, 0, queue);

if (source) 
{ 
dispatch_source_set_event_handler(source, ^{ 
MyProcessSIGHUP(); 
});

  // Start processing signals 
  dispatch_resume(source); 
} 
} 

監控進程

進程dispatch source可以監控特定進程的行為，并適當地響應。父進程可以使用dispatch source來監控自己創建的所有子進程，例如監控子進程的死亡;類似地，子進程也可以使用dispatch source來監控父進程，例如在父進程退出時自己也退出。

下面例子安裝了一個進程dispatch source，監控父進程的終止。當父進程退出時，dispatch source設置一些內部狀態信息，告知子進程自己應該退出。MySetAppExitFlag函數應該設置一個適當的標志，允許子進程終止。由于dispatch source自主運行，因此自己擁有自己，在程序關閉時會取消并釋放自己。

void MonitorParentProcess() 
{ 
pid_t parentPID = getppid();

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_PROC, 
parentPID, DISPATCH_PROC_EXIT, queue); 
if (source) 
{ 
dispatch_source_set_event_handler(source, ^{ 
MySetAppExitFlag(); 
dispatch_source_cancel(source); 
dispatch_release(source); 
}); 
dispatch_resume(source); 
} 
} 

取消一個Dispatch Source

除非你顯式地調用 dispatch_source_cancel函數，dispatch source將一直保持活動，取消一個dispatch source會停止遞送新事件，并且不能撤銷。因此你通常在取消dispatch source后立即釋放它：

void RemoveDispatchSource(dispatch_source_t mySource) 
{ 
dispatch_source_cancel(mySource); 
dispatch_release(mySource); 
} 

取消一個dispatch source是異步操作，調用 dispatch_source_cancel 之后，不會再有新的事件被處理，但是正在被dispatch source處理的事件會繼續被處理完成。在處理完最后的事件之后，dispatch source會執行自己的取消處理器。

取消處理器是你最后的執行機會，在那里執行內存或資源的釋放工作。例如描述符或mach port類型的dispatch source，必須提供取消處理器，用來關閉描述符或mach port

掛起和繼續Dispatch Source

你可以使用 dispatch_suspend 和dispatch_resume 臨時地掛起和繼續dispatch source的事件遞送。這兩個函數分別增加和減少dispatch對象的掛起計數。因此，你必須每次dispatch_suspend 調用之后，都需要相應的 dispatch_resume 才能繼續事件遞送。

掛起一個dispatch source期間，發生的任何事件都會被累積，直到dispatch source繼續。但是不會遞送所有事件，而是先合并到單一事件，然后再一次遞送。例如你監控一個文件的文件名變化，就只會遞送最后一次的變化事件