CocoaAsyncSocket---Connect （下）
前言：
注：文中涉及程式碼比較多，建議大家結合原始碼一起閱讀比較容易能加深理解。這裡有大神標註好註釋的原始碼，有需要的可以作為參照：CocoaAsyncSocket原始碼註釋
上文我們提到了GCDAsyncSocket的初始化，以及最終connect之前的準備工作，包括一些錯誤檢查；本機地址建立以及socket建立；服務端地址的建立；還有一些本機socket可選項的配置，例如禁止網路出錯導致程式關閉的訊號等。
言歸正傳，繼續上文往下講
上文講到了本文方法八--建立Socket，其中有這麼一行程式碼：
//和connectInterface繫結
if (![self bindSocket:socketFD toInterface:connectInterface error:errPtr])
{
//繫結失敗，直接關閉返回
[self closeSocket:socketFD];
return SOCKET_NULL;
}
我們去用之前建立的本機地址去做socket繫結，接著會呼叫到如下方法中：
本文方法九--給Socket繫結本機地址
//繫結一個Socket的本地地址
- (BOOL)bindSocket:(int)socketFD toInterface:(NSData *)connectInterface error:(NSError **)errPtr
{
// Bind the socket to the desired interface (if needed)
//無介面就不繫結，connect會自動繫結到一個不衝突的埠上去。
if (connectInterface)
{
LogVerbose(@"Binding socket...");
//判斷當前地址的Port是不是大於0
if ([[self class] portFromAddress:connectInterface] > 0)
{
// Since we're going to be binding to a specific port,
// we should turn on reuseaddr to allow us to override sockets in time_wait.
int reuseOn = 1;
//設定呼叫close(socket)後,仍可繼續重用該socket。呼叫close(socket)一般不會立即關閉socket，而經歷TIME_WAIT的過程。
setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));
}
//拿到地址
const struct sockaddr *interfaceAddr = (const struct sockaddr *)[connectInterface bytes];
//繫結這個地址
int result = bind(socketFD, interfaceAddr, (socklen_t)[connectInterface length]);
//繫結出錯，返回NO
if (result != 0)
{
if (errPtr)
*errPtr = [self errnoErrorWithReason:@"Error in bind() function"];
return NO;
}
}
//成功
return YES;
}
這個方法也非常簡單，如果沒有connectInterface則直接返回YES，當socket進行連線的時候，會自動繫結一個埠，進行連線。
如果有值，則我們開始繫結到我們一開始指定的地址上。
這裡呼叫了兩個和scoket相關的函式：
第一個是我們之前提到的配置scoket引數的函式：
setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));
這裡呼叫這個函式的主要目的是為了呼叫close的時候，不立即去關閉socket連線，而是經歷一個TIME_WAIT過程。在這個過程中，socket是可以被複用的。我們注意到之前的connect流程並沒有看到複用socket的程式碼。注意，我們現在走的連線流程是客戶端的流程，等我們講到服務端accept進行連線的時候，我們就能看到這個複用的作用了。
第二個是bind函式
int result = bind(socketFD, interfaceAddr, (socklen_t)[connectInterface length]);
這個函式倒是很簡單，就3個引數，socket、需要繫結的地址、地址大小。這樣就把socket和這個地址（其實就是埠）捆綁在一起了。
這樣我們就做完了最終連線前所有準備工作，本機socket有了，服務端的地址也有了。接著我們就可以開始進行最終連線了：
本文方法十 -- 建立連線的最終方法
//連線最終方法 3 finnal。。。
- (void)connectSocket:(int)socketFD address:(NSData *)address stateIndex:(int)aStateIndex
{
// If there already is a socket connected, we close socketFD and return
//已連線，關閉連線返回
if (self.isConnected)
{
[self closeSocket:socketFD];
return;
}
// Start the connection process in a background queue
//開始連線過程，在後臺queue中
__weak GCDAsyncSocket *weakSelf = self;
//獲取到全域性Queue
dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//新執行緒
dispatch_async(globalConcurrentQueue, ^{
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"
//呼叫connect方法，該函式阻塞執行緒，所以要非同步新執行緒
//客戶端向特定網路地址的伺服器傳送連線請求，連線成功返回0，失敗返回 -1。
int result = connect(socketFD, (const struct sockaddr *)[address bytes], (socklen_t)[address length]);
//老樣子，安全判斷
__strong GCDAsyncSocket *strongSelf = weakSelf;
if (strongSelf == nil) return_from_block;
//在socketQueue中，開闢執行緒
dispatch_async(strongSelf->socketQueue, ^{ @autoreleasepool {
//如果狀態為已經連線，關閉連線返回
if (strongSelf.isConnected)
{
[strongSelf closeSocket:socketFD];
return_from_block;
}
//說明連線成功
if (result == 0)
{
//關閉掉另一個沒用的socket
[self closeUnusedSocket:socketFD];
//呼叫didConnect，生成stream，改變狀態等等！
[strongSelf didConnect:aStateIndex];
}
//連線失敗
else
{
//關閉當前socket
[strongSelf closeSocket:socketFD];
// If there are no more sockets trying to connect, we inform the error to the delegate
//返回連線錯誤的error
if (strongSelf.socket4FD == SOCKET_NULL && strongSelf.socket6FD == SOCKET_NULL)
{
NSError *error = [strongSelf errnoErrorWithReason:@"Error in connect() function"];
[strongSelf didNotConnect:aStateIndex error:error];
}
}
}});
#pragma clang diagnostic pop
});
//輸出正在連線中
LogVerbose(@"Connecting...");
}
這個方法主要就是做了一件事，呼叫下面一個函式進行連線：
int result = connect(socketFD, (const struct sockaddr *)[address bytes], (socklen_t)[address length]);
這裡需要注意的是這個函式是阻塞，直到結果返回之前，執行緒會一直停在這行。所以這裡用的是全域性併發佇列，開闢了一個新的執行緒進行連線，在得到結果之後，又調回socketQueue中進行後續操作。
如果result為0，說明連線成功，我們會關閉掉另外一個沒有用到的socket（如果有的話）。然後呼叫另外一個方法做一些連線成功的初始化操作。
否則連線失敗，我們會關閉socket，填充錯誤並且返回。
我們接著來看看連線成功後，初始化的方法：
本文方法十一 -- 連線成功後的初始化
//連線成功後呼叫，設定一些連線成功的狀態
- (void)didConnect:(int)aStateIndex
{
LogTrace();
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
//狀態不同
if (aStateIndex != stateIndex)
{
LogInfo(@"Ignoring didConnect, already disconnected");
// The connect operation has been cancelled.
// That is, socket was disconnected, or connection has already timed out.
return;
}
//kConnected合併到當前flag中
flags |= kConnected;
//停止連線超時
[self endConnectTimeout];
#if TARGET_OS_IPHONE
// The endConnectTimeout method executed above incremented the stateIndex.
//上面的endConnectTimeout,會導致stateIndex增加，所以需要重新賦值
aStateIndex = stateIndex;
#endif
// Setup read/write streams (as workaround for specific shortcomings in the iOS platform)
//
// Note:
// There may be configuration options that must be set by the delegate before opening the streams.
//開啟stream之前必須用相關配置設定代理
// The primary example is the kCFStreamNetworkServiceTypeVoIP flag, which only works on an unopened stream.
//主要的例子是kCFStreamNetworkServiceTypeVoIP標記，只能工作在未開啟的stream中？
//
// Thus we wait until after the socket:didConnectToHost:port: delegate method has completed.
//所以我們要等待，連線完成的代理呼叫完
// This gives the delegate time to properly configure the streams if needed.
//這些給了代理時間，去正確的配置Stream，如果是必要的話
//建立個Block來初始化Stream
dispatch_block_t SetupStreamsPart1 = ^{
NSLog(@"hello~");
#if TARGET_OS_IPHONE
//建立讀寫stream失敗，則關閉並報對應錯誤
if (![self createReadAndWriteStream])
{
[self closeWithError:[self otherError:@"Error creating CFStreams"]];
return;
}
//引數是給NO的，就是有可讀bytes的時候，不會呼叫回撥函式
if (![self registerForStreamCallbacksIncludingReadWrite:NO])
{
[self closeWithError:[self otherError:@"Error in CFStreamSetClient"]];
return;
}
#endif
};
//part2設定stream
dispatch_block_t SetupStreamsPart2 = ^{
#if TARGET_OS_IPHONE
//狀態不一樣直接返回
if (aStateIndex != stateIndex)
{
// The socket has been disconnected.
return;
}
//如果加到runloop上失敗
if (![self addStreamsToRunLoop])
{
//錯誤返回
[self closeWithError:[self otherError:@"Error in CFStreamScheduleWithRunLoop"]];
return;
}
//讀寫stream open
if (![self openStreams])
{
//開啟錯誤返回
[self closeWithError:[self otherError:@"Error creating CFStreams"]];
return;
}
#endif
};
// Notify delegate
//通知代理
//拿到server端的host port
NSString *host = [self connectedHost];
uint16_t port = [self connectedPort];
//拿到unix域的 url
NSURL *url = [self connectedUrl];
//拿到代理
__strong id theDelegate = delegate;
//代理佇列 和 Host不為nil 且響應didConnectToHost代理方法
if (delegateQueue && host != nil && [theDelegate respondsToSelector:@selector(socket:didConnectToHost:port:)])
{
//呼叫初始化stream1
SetupStreamsPart1();
dispatch_async(delegateQueue, ^{ @autoreleasepool {
//到代理佇列呼叫連線成功的代理方法
[theDelegate socket:self didConnectToHost:host port:port];
//然後回到socketQueue中去執行初始化stream2
dispatch_async(socketQueue, ^{ @autoreleasepool {
SetupStreamsPart2();
}});
}});
}
//這個是unix domain 請求回撥
else if (delegateQueue && url != nil && [theDelegate respondsToSelector:@selector(socket:didConnectToUrl:)])
{
SetupStreamsPart1();
dispatch_async(delegateQueue, ^{ @autoreleasepool {
[theDelegate socket:self didConnectToUrl:url];
dispatch_async(socketQueue, ^{ @autoreleasepool {
SetupStreamsPart2();
}});
}});
}
//否則只初始化stream
else
{
SetupStreamsPart1();
SetupStreamsPart2();
}
// Get the connected socket
int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : (socket6FD != SOCKET_NULL) ? socket6FD : socketUN;
//fcntl,功能描述：根據檔案描述詞來操作檔案的特性。http://blog.csdn.net/pbymw8iwm/article/details/7974789
// Enable non-blocking IO on the socket
//使socket支援非阻塞IO
int result = fcntl(socketFD, F_SETFL, O_NONBLOCK);
if (result == -1)
{
//失敗 ，報錯
NSString *errMsg = @"Error enabling non-blocking IO on socket (fcntl)";
[self closeWithError:[self otherError:errMsg]];
return;
}
// Setup our read/write sources
//初始化讀寫source
[self setupReadAndWriteSourcesForNewlyConnectedSocket:socketFD];
// Dequeue any pending read/write requests
//開始下一個任務
[self maybeDequeueRead];
[self maybeDequeueWrite];
}
這個方法很長一大串，其實做的東西也很簡單，主要做了下面幾件事：
- 把當前狀態flags加上已連線，並且關閉掉我們一開始連線開啟的，連線超時的定時器。
- 初始化了兩個
Block：SetupStreamsPart1、SetupStreamsPart2，這兩個Block做的事都和讀寫流有關。SetupStreamsPart1用來建立讀寫流，並且註冊回撥。另一個SetupStreamsPart2用來把流新增到當前執行緒的runloop上，並且開啟流。 - 判斷是否有代理
queue、host或者url這些引數是否為空、是否代理響應didConnectToHost或didConnectToUrl代理，這兩種分別對應了普通socket連線和unix domin socket連線。如果實現了對應的代理，則呼叫連線成功的代理。 - 在呼叫代理的同時，呼叫了我們之前初始化的兩個讀寫流相關的
Block。這裡值得說下的是這兩個Block和代理之間的呼叫順序：
-
先執行
SetupStreamsPart1後執行SetupStreamsPart2，沒什麼好說的，問題是代理的執行時間，想想如果我們放在SetupStreamsPart2後面是不是會導致個問題，就是使用者收到訊息了，但是連線成功的代理還沒有被呼叫，這顯然是不合理的。所以我們的呼叫順序是SetupStreamsPart1->代理->SetupStreamsPart2所以出現瞭如下程式碼：
//呼叫初始化stream1
SetupStreamsPart1();
dispatch_async(delegateQueue, ^{ @autoreleasepool {
//到代理佇列呼叫連線成功的代理方法
[theDelegate socket:self didConnectToHost:host port:port];
//然後回到socketQueue中去執行初始化stream2
dispatch_async(socketQueue, ^{ @autoreleasepool {
SetupStreamsPart2();
}});
}});
原因是為了執行緒安全和socket相關的操作必須在socketQueue中進行。而代理必須在我們設定的代理queue中被回撥。
- 拿到當前的本機socket，呼叫如下函式：
int result = fcntl(socketFD, F_SETFL, O_NONBLOCK);
簡單來說，這個函式類似我們之前提到的一個函式setsockopt()，都是給socket設定一些引數，以實現一些功能。而這個函式，能實現的功能更多。大家可以看看這篇文章參考參考：fcntl函式詳解
而在這裡，就是為了把socket的IO模式設定為非阻塞。很多小夥伴又要疑惑什麼是非阻塞了，先別急，關於這個我們下文會詳細的來談。
我們初始化了讀寫source（很重要，所有的訊息都是由這個source來觸發的，我們之後會詳細分析這個方法）。
我們做完了
stream和source的初始化處理，則開始做一次讀寫任務（這兩個方法暫時不講，會放到之後的Read和Write篇中去講）。
我們接著來講講這個方法中對其他方法的呼叫，按照順序來，先從第2條，兩個Block中對stream的處理開始。和stream相關的函式一共有6個：
Stream相關方法一 -- 建立讀寫stream
//建立讀寫stream
- (BOOL)createReadAndWriteStream
{
LogTrace();
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
//如果有一個有值，就返回
if (readStream || writeStream)
{
// Streams already created
return YES;
}
//拿到socket，首選是socket4FD，其次socket6FD，都沒有才是socketUN，socketUN應該是Unix的socket結構體
int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : (socket6FD != SOCKET_NULL) ? socket6FD : socketUN;
//如果都為空，返回NO
if (socketFD == SOCKET_NULL)
{
// Cannot create streams without a file descriptor
return NO;
}
//如果非連線，返回NO
if (![self isConnected])
{
// Cannot create streams until file descriptor is connected
return NO;
}
LogVerbose(@"Creating read and write stream...");
#pragma mark - 繫結Socket和CFStream
//下面的介面用於建立一對 socket stream，一個用於讀取，一個用於寫入：
CFStreamCreatePairWithSocket(NULL, (CFSocketNativeHandle)socketFD, &readStream, &writeStream);
// The kCFStreamPropertyShouldCloseNativeSocket property should be false by default (for our case).
// But let's not take any chances.
//讀寫stream都設定成不會隨著繫結的socket一起close,release。 kCFBooleanFalse不一起，kCFBooleanTrue一起
if (readStream)
CFReadStreamSetProperty(readStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
if (writeStream)
CFWriteStreamSetProperty(writeStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
//如果有一個為空
if ((readStream == NULL) || (writeStream == NULL))
{
LogWarn(@"Unable to create read and write stream...");
//關閉對應的stream
if (readStream)
{
CFReadStreamClose(readStream);
CFRelease(readStream);
readStream = NULL;
}
if (writeStream)
{
CFWriteStreamClose(writeStream);
CFRelease(writeStream);
writeStream = NULL;
}
//返回建立失敗
return NO;
}
//建立成功
return YES;
}
這個方法基本上很簡單，就是關於兩個stream函式的呼叫：
- 建立stream的函式：
CFStreamCreatePairWithSocket(NULL, (CFSocketNativeHandle)socketFD, &readStream, &writeStream);
這個函式建立了一對讀寫stream，並且把stream與這個scoket做了繫結。
- 設定stream屬性：
CFReadStreamSetProperty(readStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
CFWriteStreamSetProperty(writeStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
這個函式可以給stream設定一個屬性，這裡是設定stream不會隨著socket的生命週期（close,release）而變化。
接著呼叫了registerForStreamCallbacksIncludingReadWrite來給stream註冊讀寫回撥。
Stream相關方法二 -- 讀寫回撥的註冊：
//註冊Stream的回撥
- (BOOL)registerForStreamCallbacksIncludingReadWrite:(BOOL)includeReadWrite
{
LogVerbose(@"%@ %@", THIS_METHOD, (includeReadWrite ? @"YES" : @"NO"));
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
//判斷讀寫stream是不是都為空
NSAssert((readStream != NULL && writeStream != NULL), @"Read/Write stream is null");
//客戶端stream上下文物件
streamContext.version = 0;
streamContext.info = (__bridge void *)(self);
streamContext.retain = nil;
streamContext.release = nil;
streamContext.copyDescription = nil;
// The open has completed successfully.
// The stream has bytes to be read.
// The stream can accept bytes for writing.
// An error has occurred on the stream.
// The end of the stream has been reached.
//設定一個CF的flag 兩種，一種是錯誤發生的時候，一種是stream事件結束
CFOptionFlags readStreamEvents = kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered ;
//如果包含讀寫
if (includeReadWrite)
//仍然有Bytes要讀的時候 The stream has bytes to be read.
readStreamEvents |= kCFStreamEventHasBytesAvailable;
//給讀stream設定客戶端，會在之前設定的那些標記下回撥函式 CFReadStreamCallback。設定失敗的話直接返回NO
if (!CFReadStreamSetClient(readStream, readStreamEvents, &CFReadStreamCallback, &streamContext))
{
return NO;
}
//寫的flag,也一樣
CFOptionFlags writeStreamEvents = kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered;
if (includeReadWrite)
writeStreamEvents |= kCFStreamEventCanAcceptBytes;
if (!CFWriteStreamSetClient(writeStream, writeStreamEvents, &CFWriteStreamCallback, &streamContext))
{
return NO;
}
//走到最後說明讀寫都設定回撥成功，返回YES
return YES;
}
相信用過CFStream的朋友，應該會覺得很簡單，這個方法就是呼叫了一些CFStream相關函式，其中最主要的這個設定讀寫回撥函式：
Boolean CFReadStreamSetClient(CFReadStreamRef stream, CFOptionFlags streamEvents, CFReadStreamClientCallBack clientCB, CFStreamClientContext *clientContext);
Boolean CFWriteStreamSetClient(CFWriteStreamRef stream, CFOptionFlags streamEvents, CFWriteStreamClientCallBack clientCB, CFStreamClientContext *clientContext);
這個函式共4個引數：
第1個為我們需要設定的stream；
第2個為需要監聽的事件選項，包括以下事件：
typedef CF_OPTIONS(CFOptionFlags, CFStreamEventType) {
kCFStreamEventNone = 0, //沒有事件發生
kCFStreamEventOpenCompleted = 1, //成功開啟流
kCFStreamEventHasBytesAvailable = 2, //流中有資料可讀
kCFStreamEventCanAcceptBytes = 4, //流中可以接受資料去寫
kCFStreamEventErrorOccurred = 8, //流發生錯誤
kCFStreamEventEndEncountered = 16 //到達流的結尾
};
其中具體用法，大家可以自行去試試，這裡作者只監聽了了兩種事件kCFStreamEventErrorOccurred和kCFStreamEventEndEncountered，再根據傳過來的引數去決定是否監聽kCFStreamEventCanAcceptBytes：
//如果包含讀寫
if (includeReadWrite)
//仍然有Bytes要讀的時候 The stream has bytes to be read.
readStreamEvents |= kCFStreamEventHasBytesAvailable;
而這裡我們傳過來的引數為NO，導致它並不監聽可讀資料。顯然，我們正常的連線，當有訊息傳送過來，並不是由stream回撥來觸發的。這個框架中，如果是TLS傳輸的socket是用stream來觸發的，這個我們後續文章會講到。
那麼有資料的時候，到底是什麼來觸發我們的讀寫呢，答案就是讀寫source，我們接下來就會去建立初始化它。
這裡繫結了兩個函式，分別對應讀和寫的回撥，分別為：
//讀的回撥
static void CFReadStreamCallback (CFReadStreamRef stream, CFStreamEventType type, void *pInfo)
//寫的回撥
static void CFWriteStreamCallback (CFWriteStreamRef stream, CFStreamEventType type, void *pInfo)
關於這兩個函式，同樣這裡暫時不做討論，等後續文章再來分析。
還有一點需要說一下的是streamContext這個屬性，它是一個結構體，包含流的上下文資訊，其結構如下：
typedef struct {
CFIndex version;
void *info;
void *(*retain)(void *info);
void (*release)(void *info);
CFStringRef (*copyDescription)(void *info);
} CFStreamClientContext;
這個流的上下文中info指標，其實就是前面所對應的讀寫回撥函式中的pInfo指標，每次回撥都會傳過去。其它的version就是流的版本標識，之外的3個都需要的是一個函式指標，對應我們傳遞的pInfo的持有以及釋放還有複製的描述資訊，這裡我們都賦值給nil。
接著我們來到流處理的第三步：addStreamsToRunLoop-新增到runloop上。
Stream相關方法三 -- 加到當前執行緒的runloop上：
//把stream新增到runloop上
- (BOOL)addStreamsToRunLoop
{
LogTrace();
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
NSAssert((readStream != NULL && writeStream != NULL), @"Read/Write stream is null");
//判斷flag裡是否包含kAddedStreamsToRunLoop，沒新增過則新增。
if (!(flags & kAddedStreamsToRunLoop))
{
LogVerbose(@"Adding streams to runloop...");
[[self class] startCFStreamThreadIfNeeded];
//在開啟的執行緒中去執行，阻塞式的
[[self class] performSelector:@selector(scheduleCFStreams:)
onThread:cfstreamThread
withObject:self
waitUntilDone:YES];
//新增標識
flags |= kAddedStreamsToRunLoop;
}
return YES;
}
這裡方法做了兩件事：
- 開啟了一條用於
CFStream讀寫回撥的常駐執行緒，其中呼叫了好幾個函式：
+ (void)startCFStreamThreadIfNeeded；
+ (void)cfstreamThread；
在這兩個函式中，新增了一個runloop，並且繫結了一個定時器事件，讓它run起來，使得執行緒常駐。大家可以結合著github中demo的註釋，自行檢視這幾個方法。如果有任何疑問可以看看樓主這篇文章：基於runloop的執行緒保活、銷燬與通訊，或者本文下評論，會一一解答。
- 在這個常駐執行緒中去呼叫註冊方法：
//註冊CFStream
+ (void)scheduleCFStreams:(GCDAsyncSocket *)asyncSocket
{
LogTrace();
//斷言當前執行緒是cfstreamThread，不是則報錯
NSAssert([NSThread currentThread] == cfstreamThread, @"Invoked on wrong thread");
//獲取到runloop
CFRunLoopRef runLoop = CFRunLoopGetCurrent();
//如果有readStream
if (asyncSocket->readStream)
//註冊readStream在runloop的kCFRunLoopDefaultMode上
CFReadStreamScheduleWithRunLoop(asyncSocket->readStream, runLoop, kCFRunLoopDefaultMode);
//一樣
if (asyncSocket->writeStream)
CFWriteStreamScheduleWithRunLoop(asyncSocket->writeStream, runLoop, kCFRunLoopDefaultMode);
}
這裡可以看到，我們流的回撥都是在這條流的常駐執行緒中，至於為什麼要這麼做，相信大家樓主看過AFNetworking系列文章的會明白。我們之後文章也會就這個框架執行緒的問題詳細討論的，這裡就暫時不詳細說明了。
這裡主要用了CFReadStreamScheduleWithRunLoop函式完成了runloop的註冊:
CFReadStreamScheduleWithRunLoop(asyncSocket->readStream, runLoop, kCFRunLoopDefaultMode);
CFWriteStreamScheduleWithRunLoop(asyncSocket->writeStream, runLoop, kCFRunLoopDefaultMode);
這樣，如果stream中有我們監聽的事件發生了，就會在這個runloop中觸發我們之前設定的讀寫回撥函式。
我們完成了註冊，接下來我們就需要開啟stream了：
Stream相關方法四 -- 開啟stream：
//開啟stream
- (BOOL)openStreams
{
LogTrace();
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
//斷言讀寫stream都不會空
NSAssert((readStream != NULL && writeStream != NULL), @"Read/Write stream is null");
//返回stream的狀態
CFStreamStatus readStatus = CFReadStreamGetStatus(readStream);
CFStreamStatus writeStatus = CFWriteStreamGetStatus(writeStream);
//如果有任意一個沒有開啟
if ((readStatus == kCFStreamStatusNotOpen) || (writeStatus == kCFStreamStatusNotOpen))
{
LogVerbose(@"Opening read and write stream...");
//開啟
BOOL r1 = CFReadStreamOpen(readStream);
BOOL r2 = CFWriteStreamOpen(writeStream);
//有一個開啟失敗
if (!r1 || !r2)
{
LogError(@"Error in CFStreamOpen");
return NO;
}
}
return YES;
}
方法也很簡單，通過CFReadStreamGetStatus函式，獲取到當前stream的狀態，判斷沒開啟則呼叫CFReadStreamOpen函式去開啟，如果開啟失敗，錯誤返回。
到這裡stream初始化相關的工作就做完了，接著我們還是回到本文方法十一 -- 連線成功後的初始化中：
其中第5條，我們談到了設定socket的I/O模式為非阻塞，相信很多朋友對socket的I/O：同步、非同步、阻塞、非阻塞。這四個概念有所混淆。
簡單的來說，同步、非同步是對於客戶端而言的。比如我發起一個呼叫一個函式，我如果直接去呼叫，那麼就是同步的，否則新開闢一個執行緒去做，那麼對於當前執行緒而言就是非同步的。
而阻塞和非阻塞是對於服務端而言。當服務端被客戶端呼叫後，我如果立刻返回撥用的結果（無論資料是否處理完）那麼就是非阻塞的，又或者等待資料拿到並且處理完（總之一系列邏輯）再返回，那麼這種情況就是阻塞的。
好了，有了這個概念，我們接下來看看Linux下的5種I/O模型:
1)阻塞I/O（blocking I/O）
2)非阻塞I/O （nonblocking I/O）
- I/O複用(select 和poll) （I/O multiplexing）
4)訊號驅動I/O （signal driven I/O (SIGIO)）
5)非同步I/O （asynchronous I/O (the POSIX aio_functions)）
我們來簡單談談這5種模型：
1）阻塞I/O：
簡單舉個例子，比如我們呼叫read()去讀取訊息，如果是在阻塞模式下，我們會一直等待，直到有訊息到來為止。
很多小夥伴可能又要說了，這有什麼不可以，我們新開闢一條執行緒，讓它等著不就行了，看起來確實沒什麼不可以。
那是因為你僅僅是站在客戶端的角度上來看。試想如果我們服務端也這麼做，那豈不是有多少個socket連線，我們得開闢多少個執行緒去做阻塞IO？
2）非阻塞I/O
於是就有了非阻塞的概念，當我們去read()的時候，直接返回結果，這樣在很大概率下，是並沒有訊息給我們讀的。這時候函式就會錯誤返回-1，並將errno設定為 EWOULDBLOCK，意為IO並沒有資料。
這時候就需要我們自己有一個機制，能知道什麼時候有資料，在去呼叫read()。有一個很傻的方式就是不停的迴圈去呼叫這個函式，這樣有資料來，我們第一時間就讀到了。
3）I/O複用模式I/O複用模式是阻塞I/O的改進版，它在read之前，會先去呼叫select去遍歷所有的socket，看哪一個有訊息。當然這個過程是阻塞的，直到有訊息返回為止。然後在去呼叫read，阻塞的方式去讀取從系統核心中去讀取這條訊息到程式中來。
4）訊號驅動I/O訊號驅動I/O是一個半非同步的I/O模式，它首先會呼叫一個系統sginal相關的函式，把socket和訊號繫結起來，然後不管有沒有訊息直接返回(這一步非阻塞)。這時候系統核心會去檢查socket是否有可用資料。有的話則傳送該訊號給程式，然後程式在去呼叫read阻塞式的從系統核心讀取資料到程式中來（這一步阻塞）。
5）可能聰明的你已經想到了更好的解決方式，這就對了，這就是我們第5種IO模式：非同步I/O ,它和第4步一樣，也是呼叫sginal相關函式，把socket和訊號繫結起來，同時繫結起來的還有一塊資料緩衝區buffer。然後無論有沒有資料直接返回（非阻塞）。而系統核心會去檢查是否有可用資料，一旦有可用資料，則觸發訊號，並且把資料填充到我們之前提供的資料緩衝區buffer中。這樣我們程式被訊號觸發，並且直接能從buffer中讀取到資料，整個過程沒有任何阻塞。
很顯然，我們CocoaAyncSocket框架用的就是第5種I/O模式。
如果大家對I/O模式仍然感到疑惑，可以看看這篇文章：
socket阻塞與非阻塞，同步與非同步、I/O模型
接著我們繼續看本文方法十一 -- 連線成功後的初始化中第6條，讀寫source的初始化方法：
本文方法十二 -- 初始化讀寫source：
//初始化讀寫source
- (void)setupReadAndWriteSourcesForNewlyConnectedSocket:(int)socketFD
{
//GCD source DISPATCH_SOURCE_TYPE_READ 會一直監視著 socketFD，直到有資料可讀
readSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socketFD, 0, socketQueue);
//_dispatch_source_type_write ：監視著 socketFD，直到寫資料了
writeSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE, socketFD, 0, socketQueue);
// Setup event handlers
__weak GCDAsyncSocket *weakSelf = self;
#pragma mark readSource的回撥
//GCD事件控制程式碼 讀，當socket中有資料流出現，就會觸發這個控制程式碼，全自動，不需要手動觸發
dispatch_source_set_event_handler(readSource, ^{ @autoreleasepool {
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"
__strong GCDAsyncSocket *strongSelf = weakSelf;
if (strongSelf == nil) return_from_block;
LogVerbose(@"readEventBlock");
//從readSource中，獲取到資料長度，
strongSelf->socketFDBytesAvailable = dispatch_source_get_data(strongSelf->readSource);
LogVerbose(@"socketFDBytesAvailable: %lu", strongSelf->socketFDBytesAvailable);
//如果長度大於0，開始讀資料
if (strongSelf->socketFDBytesAvailable > 0)
[strongSelf doReadData];
else
//因為觸發了，但是卻沒有可讀資料，說明讀到當前包邊界了。做邊界處理
[strongSelf doReadEOF];
#pragma clang diagnostic pop
}});
//寫事件控制程式碼
dispatch_source_set_event_handler(writeSource, ^{ @autoreleasepool {
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"
__strong GCDAsyncSocket *strongSelf = weakSelf;
if (strongSelf == nil) return_from_block;
LogVerbose(@"writeEventBlock");
//標記為接受資料
strongSelf->flags |= kSocketCanAcceptBytes;
//開始寫
[strongSelf doWriteData];
#pragma clang diagnostic pop
}});
// Setup cancel handlers
__block int socketFDRefCount = 2;
#if !OS_OBJECT_USE_OBJC
dispatch_source_t theReadSource = readSource;
dispatch_source_t theWriteSource = writeSource;
#endif
//讀寫取消的控制程式碼
dispatch_source_set_cancel_handler(readSource, ^{
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"
LogVerbose(@"readCancelBlock");
#if !OS_OBJECT_USE_OBJC
LogVerbose(@"dispatch_release(readSource)");
dispatch_release(theReadSource);
#endif
if (--socketFDRefCount == 0)
{
LogVerbose(@"close(socketFD)");
//關閉socket
close(socketFD);
}
#pragma clang diagnostic pop
});
dispatch_source_set_cancel_handler(writeSource, ^{
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"
LogVerbose(@"writeCancelBlock");
#if !OS_OBJECT_USE_OBJC
LogVerbose(@"dispatch_release(writeSource)");
dispatch_release(theWriteSource);
#endif
if (--socketFDRefCount == 0)
{
LogVerbose(@"close(socketFD)");
//關閉socket
close(socketFD);
}
#pragma clang diagnostic pop
});
// We will not be able to read until data arrives.
// But we should be able to write immediately.
//設定未讀數量為0
socketFDBytesAvailable = 0;
//把讀掛起的狀態移除
flags &= ~kReadSourceSuspended;
LogVerbose(@"dispatch_resume(readSource)");
//開啟讀source
dispatch_resume(readSource);
//標記為當前可接受資料
flags |= kSocketCanAcceptBytes;
//先把寫source標記為掛起
flags |= kWriteSourceSuspended;
}
這個方法初始化了讀寫source，這個方法主要是GCD source運用，如果有對這部分知識有所疑問，可以看看宜龍大神這篇:GCD高階用法。
這裡GCD Source相關的主要是下面這3個函式：
//建立source
dispatch_source_create(dispatch_source_type_t type,
uintptr_t handle,
unsigned long mask,
dispatch_queue_t _Nullable queue);
//為source設定事件控制程式碼
dispatch_source_set_event_handler(dispatch_source_t source,
dispatch_block_t _Nullable handler);
//為source設定取消控制程式碼
dispatch_source_set_cancel_handler(dispatch_source_t source,
dispatch_block_t _Nullable handler);
相信大家用至少用過GCD定時器，接觸過這3個函式，這裡建立source的函式，根據引數type的不同，可以處理不同的事件：
這裡我們用的是DISPATCH_SOURCE_TYPE_READ和DISPATCH_SOURCE_TYPE_WRITE這兩個型別。標識如果handle如果有可讀或者可寫資料時，會觸發我們的事件控制程式碼。
- 而這裡初始化的讀寫事件控制程式碼內容也很簡單，就是去讀寫資料。
- 而取消控制程式碼也就是去關閉
socket。 - 初始化完成後，我們開啟了
readSource，一旦有資料過來就觸發了我們readSource事件控制程式碼，就可以去監聽的socket所分配的緩衝區中去讀取資料了，而wirteSource初始化完是掛起的。 - 除此之外我們還初始化了當前
source的狀態，用於我們後續的操作。
至此我們客戶端的整個Connect流程結束了，用一張圖來概括總結一下吧：
Connect流程.png
整個客戶端連線的流程大致如上圖，當然遠不及於此，這裡我們對地址做了IPV4和IPV6的相容處理，對一些使用socket而產生的網路錯誤導致程式退出的容錯處理。以及在這個過程中，socketQueue、代理queue、全域性併發queue和stream常駐執行緒的管理排程等等。
當然其中絕大部分操作都是在socketQueue中進行的。而在socketQueue中，我們也分為兩種操作dispatch_sync和dispatch_async。
因為socketQueue本身就是一個序列queue，所以我們所有的操作都在這個queue中進行保證了執行緒安全，而需要阻塞後續行為的操作，我們用了sync的方式。其實這樣使用sync是及其容易死鎖的，但是作者每次在呼叫sync之前都呼叫了這麼一行判斷：
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
判斷當前佇列是否就是這個socketQueue佇列，如果是則直接呼叫，否則就用sync的方式提交到這個queue中去執行。這種防死鎖的方式，你學到了麼？
接著我們來講講服務端Accept流程：
整個流程還是相對Connect來說還是十分簡單的，因為這個方法很長，而且大多數是我們直接連線講到過得內容，所以我省略了一部分的程式碼，只把重要的展示出來，大家可以參照著原始碼看。
//監聽埠起點
- (BOOL)acceptOnPort:(uint16_t)port error:(NSError **)errPtr
{
return [self acceptOnInterface:nil port:port error:errPtr];
}
- (BOOL)acceptOnInterface:(NSString *)inInterface port:(uint16_t)port error:(NSError **)errPtr
{
LogTrace();
// Just in-case interface parameter is immutable.
//防止引數被修改
NSString *interface = [inInterface copy];
__block BOOL result = NO;
__block NSError *err = nil;
// CreateSocket Block
// This block will be invoked within the dispatch block below.
//建立socket的Block
int(^createSocket)(int, NSData*) = ^int (int domain, NSData *interfaceAddr) {
//建立TCP的socket
int socketFD = socket(domain, SOCK_STREAM, 0);
//一系列錯誤判斷
...
// Bind socket
//用本地地址去繫結
status = bind(socketFD, (const struct sockaddr *)[interfaceAddr bytes], (socklen_t)[interfaceAddr length]);
//監聽這個socket
//第二個引數是這個埠下維護的socket請求佇列，最多容納的使用者請求數。
status = listen(socketFD, 1024);
return socketFD;
};
// Create dispatch block and run on socketQueue
dispatch_block_t block = ^{ @autoreleasepool {
//一系列錯誤判斷
...
//判斷ipv4 ipv6是否支援
...
//得到本機的IPV4 IPV6的地址
[self getInterfaceAddress4:&interface4 address6:&interface6 fromDescription:interface port:port];
...
//判斷可以用IPV4還是6進行請求
...
// Create accept sources
//建立接受連線被觸發的source
if (enableIPv4)
{
//接受連線的source
accept4Source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socket4FD, 0, socketQueue);
//事件控制程式碼
dispatch_source_set_event_handler(accept4Source, ^{ @autoreleasepool {
//拿到資料，連線數
unsigned long numPendingConnections = dispatch_source_get_data(acceptSource);
LogVerbose(@"numPendingConnections: %lu", numPendingConnections);
//迴圈去接受這些socket的事件(一次觸發可能有多個連線)
while ([strongSelf doAccept:socketFD] && (++i < numPendingConnections));
}});
//取消控制程式碼
dispatch_source_set_cancel_handler(accept4Source, ^{
//...
//關閉socket
close(socketFD);
});
//開啟source
dispatch_resume(accept4Source);
}
//ipv6一樣
...
//在scoketQueue中同步做這些初始化。
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
else
dispatch_sync(socketQueue, block);
//...錯誤判斷
//返回結果
return result;
}
這個方法省略完仍然有這麼長，它主要做了這兩件事（篇幅原因，儘量精簡）：
- 建立本機地址、建立socket、繫結埠、監聽埠。
- 建立了一個
GCD Source，來監聽這個socket讀source，這樣連線事件一發生，就會觸發我們的事件控制程式碼。接著我們呼叫了doAccept:方法迴圈去接受所有的連線。
接著我們來看這個接受連線的方法（同樣省略了一部分不那麼重要的程式碼）：
//連線接受的方法
- (BOOL)doAccept:(int)parentSocketFD
{
LogTrace();
int socketType;
int childSocketFD;
NSData *childSocketAddress;
//IPV4
if (parentSocketFD == socket4FD)
{
socketType = 0;
struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
//呼叫接受，得到接受的子socket
childSocketFD = accept(parentSocketFD, (struct sockaddr *)&addr, &addrLen);
//NO說明沒有連線
if (childSocketFD == -1)
{
LogWarn(@"Accept failed with error: %@", [self errnoError]);
return NO;
}
//子socket的地址資料
childSocketAddress = [NSData dataWithBytes:&addr length:addrLen];
}
//一樣
else if (parentSocketFD == socket6FD)
{
...
}
//unix domin socket 一樣
else // if (parentSocketFD == socketUN)
{
...
}
//socket 配置項的設定... 和connect一樣
//響應代理
if (delegateQueue)
{
__strong id theDelegate = delegate;
//代理佇列中呼叫
dispatch_async(delegateQueue, ^{ @autoreleasepool {
// Query delegate for custom socket queue
dispatch_queue_t childSocketQueue = NULL;
//判斷是否實現了為socket 生成一個新的SocketQueue，是的話拿到新queue
if ([theDelegate respondsToSelector:@selector(newSocketQueueForConnectionFromAddress:onSocket:)])
{
childSocketQueue = [theDelegate newSocketQueueForConnectionFromAddress:childSocketAddress
onSocket:self];
}
// Create GCDAsyncSocket instance for accepted socket
//新建立一個本類例項，給接受的socket
GCDAsyncSocket *acceptedSocket = [[[self class] alloc] initWithDelegate:theDelegate
delegateQueue:delegateQueue
socketQueue:childSocketQueue];
//IPV4 6 un
if (socketType == 0)
acceptedSocket->socket4FD = childSocketFD;
else if (socketType == 1)
acceptedSocket->socket6FD = childSocketFD;
else
acceptedSocket->socketUN = childSocketFD;
//標記開始 並且已經連線
acceptedSocket->flags = (kSocketStarted | kConnected);
// Setup read and write sources for accepted socket
//初始化讀寫source
dispatch_async(acceptedSocket->socketQueue, ^{ @autoreleasepool {
[acceptedSocket setupReadAndWriteSourcesForNewlyConnectedSocket:childSocketFD];
}});
//判斷代理是否實現了didAcceptNewSocket方法，把我們新建立的socket返回出去
if ([theDelegate respondsToSelector:@selector(socket:didAcceptNewSocket:)])
{
[theDelegate socket:self didAcceptNewSocket:acceptedSocket];
}
}});
}
return YES;
}
- 這個方法很簡單，核心就是呼叫下面這個函式，去接受連線，並且拿到一個新的
socket
childSocketFD = accept(parentSocketFD, (struct sockaddr *)&addr, &addrLen);
- 然後呼叫了
newSocketQueueForConnectionFromAddress:onSocket:這個代理，可以為新的socket重新設定一個socketQueue。 - 接著我們用這個
Socket重新建立了一個GCDAsyncSocket例項，然後呼叫我們的代理didAcceptNewSocket方法，把這個例項給傳出去了。 - 這裡需要注意的是，我們呼叫
didAcceptNewSocket代理方法傳出去的例項我們需要自己保留，不然就會被釋放掉，那麼這個與客戶端的連線也就斷開了。 - 同時我們還初始化了這個新
socket的讀寫source，這一步完全和connect中一樣，呼叫同一個方法，這樣如果有讀寫資料，就會觸發這個新的socket的source了。
建立連線之後的無數個新的socket，都是獨立的，它們處理讀寫連線斷開的邏輯就和客戶端socket完全一樣了。
而我們監聽本機埠的那個socket始終只有一個，這個用來監聽觸發socket連線，並返回建立我們這無數個新的socket例項。
作為服務端的Accept流程就這麼結束了，因為篇幅原因，所以儘量精簡了一些細節的處理，不過這些處理在Connect中也是反覆出現的，所以基本無傷大雅。如果大家會感到困惑，建議下載github中的原始碼註釋，對照著再看一遍，相信會有幫助的。
接著我們來講講Unix Domin Socket建立本地程式通訊流程：
基本上這個流程，比上述任何流程還要簡單，簡單的到即使不簡化程式碼，也沒多少行（當然這是建立在客戶端Connect流程已經實現了很多公用方法的基礎上）。
接著進入正題，我們來看看它發起連線的方法：
//連線本機的url上，IPC，程式間通訊
- (BOOL)connectToUrl:(NSURL *)url withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr;
{
LogTrace();
__block BOOL result = NO;
__block NSError *err = nil;
dispatch_block_t block = ^{ @autoreleasepool {
//判斷長度
if ([url.path length] == 0)
{
NSString *msg = @"Invalid unix domain socket url.";
err = [self badParamError:msg];
return_from_block;
}
// Run through standard pre-connect checks
//前置的檢查
if (![self preConnectWithUrl:url error:&err])
{
return_from_block;
}
// We've made it past all the checks.
// It's time to start the connection process.
flags |= kSocketStarted;
// Start the normal connection process
NSError *connectError = nil;
//呼叫另一個方法去連線
if (![self connectWithAddressUN:connectInterfaceUN error:&connectError])
{
[self closeWithError:connectError];
return_from_block;
}
[self startConnectTimeout:timeout];
result = YES;
}};
//在socketQueue中同步執行
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
else
dispatch_sync(socketQueue, block);
if (result == NO)
{
if (errPtr)
*errPtr = err;
}
return result;
}
連線方法非常簡單，就只是做了一些錯誤的處理，然後呼叫了其他的方法，包括一個前置檢查，這檢查中會去判斷各種引數是否正常，如果正常會返回YES，並且把url轉換成Uinix domin socket地址的結構體，賦值給我們的屬性connectInterfaceUN。
接著呼叫了connectWithAddressUN方法去發起連線。
我們接著來看看這個方法：
//連線Unix域伺服器
- (BOOL)connectWithAddressUN:(NSData *)address error:(NSError **)errPtr
{
LogTrace();
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
// Create the socket
int socketFD;
LogVerbose(@"Creating unix domain socket");
//建立本機socket
socketUN = socket(AF_UNIX, SOCK_STREAM, 0);
socketFD = socketUN;
if (socketFD == SOCKET_NULL)
{
if (errPtr)
*errPtr = [self errnoErrorWithReason:@"Error in socket() function"];
return NO;
}
// Bind the socket to the desired interface (if needed)
LogVerbose(@"Binding socket...");
int reuseOn = 1;
//設定可複用
setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));
// Prevent SIGPIPE signals
int nosigpipe = 1;
//程式終止錯誤訊號禁止
setsockopt(socketFD, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe, sizeof(nosigpipe));
// Start the connection process in a background queue
int aStateIndex = stateIndex;
dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(globalConcurrentQueue, ^{
const struct sockaddr *addr = (const struct sockaddr *)[address bytes];
//並行佇列呼叫連線
int result = connect(socketFD, addr, addr->sa_len);
if (result == 0)
{
dispatch_async(socketQueue, ^{ @autoreleasepool {
//連線成功的一些狀態初始化
[self didConnect:aStateIndex];
}});
}
else
{
// 失敗的處理
perror("connect");
NSError *error = [self errnoErrorWithReason:@"Error in connect() function"];
dispatch_async(socketQueue, ^{ @autoreleasepool {
[self didNotConnect:aStateIndex error:error];
}});
}
});
LogVerbose(@"Connecting...");
return YES;
}
主要部分基本和客戶端連線相同，並且簡化了很多，呼叫了這一行完成了連線：
int result = connect(socketFD, addr, addr->sa_len);
同樣也和客戶端一樣，在連線成功之後去呼叫下面這個方法完成了一些資源的初始化：
[self didConnect:aStateIndex];
基本上連線就這麼兩個方法了（當然我們省略了一些細節），看完客戶端的連線之後，到這就變得非常簡單了。
接著我們來看看uinix domin socket作為服務端Accept。
這個Accpet，基本和我們普通Socket服務端的Accept相同。
//接受一個Url，uniex domin socket 做為服務端
- (BOOL)acceptOnUrl:(NSURL *)url error:(NSError **)errPtr;
{
LogTrace();
__block BOOL result = NO;
__block NSError *err = nil;
//基本和正常的socket accept一模一樣
// CreateSocket Block
// This block will be invoked within the dispatch block below.
//生成一個建立socket的block，建立、繫結、監聽
int(^createSocket)(int, NSData*) = ^int (int domain, NSData *interfaceAddr) {
//creat socket
...
// Set socket options
...
// Bind socket
...
// Listen
...
};
// Create dispatch block and run on socketQueue
//錯誤判斷
dispatch_block_t block = ^{ @autoreleasepool {
//錯誤判斷
...
//判斷是否有這個url路徑是否正確
...
//呼叫上面的Block建立socket，並且繫結監聽。
...
//建立接受連線的source
acceptUNSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socketUN, 0, socketQueue);
int socketFD = socketUN;
dispatch_source_t acceptSource = acceptUNSource;
//事件控制程式碼，和accpept一樣
dispatch_source_set_event_handler(acceptUNSource, ^{ @autoreleasepool {
//迴圈去接受所有的每一個連線
...
}});
//取消控制程式碼
dispatch_source_set_cancel_handler(acceptUNSource, ^{
//關閉socket
close(socketFD);
});
LogVerbose(@"dispatch_resume(accept4Source)");
dispatch_resume(acceptUNSource);
flags |= kSocketStarted;
result = YES;
}};
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
else
dispatch_sync(socketQueue, block);
//填充錯誤
if (result == NO)
{
LogInfo(@"Error in accept: %@", err);
if (errPtr)
*errPtr = err;
}
return result;
}
因為程式碼基本雷同，所以我們省略了大部分程式碼，大家可以參照著之前的講解或者原始碼去理解。這裡和普通服務端socket唯一的區別就是，這裡服務端繫結的地址是unix domin socket型別的地址，它是一個結構體，裡面包含的是我們進行程式通訊的紐帶-一個本機檔案路徑。
所以這裡服務端簡單來說就是繫結的這個檔案路徑，當這個檔案路徑有資料可讀（即有客戶端連線到達）的時候，會觸發初始化的source事件控制程式碼，我們會去迴圈的接受所有的連線，並且新生成一個socket例項，這裡和普通的socket完全一樣。
就這樣我們所有的連線方式已經講完了，後面這兩種方式，為了節省篇幅，確實講的比較粗略，但是核心的部分都有提到。
另外如果你有理解客戶端的Connect流程，那麼理解起來應該沒有什麼問題，這兩個流程比前者可簡化太多了。
寫在結尾：
這個框架的
Connect篇到此為止了，其實想一篇結束一塊內容的，但是程式碼量實在太多，如果講的太粗略，大家也很難去學習到真正的內容。但是樓主也不想寫的太長，太瑣碎，相信大家都很難看下去，不過萬幸能兩篇內總結完。
相關文章
- jquery選擇div下的ul下的li下的ajQuery
- webpack安裝教程windows下、mac下WebWindowsMac
- 當下
- 下白
- 下載
- Windows下Oracle的下載與安裝WindowsOracle
- 原始碼下載，軟體下載，遊戲下載www.sixgod.net原始碼遊戲Go
- ManagerForMacMAC版下載_ManagerForMac免費版下載ORMMacACM
- 多執行緒下載工具 NeatDownloadManager下載執行緒
- 快過年了，總結下，發洩下
- Mac下根據nvm下載node指定版本Mac
- Linux下jdk1.8的下載安裝LinuxJDK
- Centos 7下下載和安裝dockerCentOSDocker
- 珍惜當下
- xampp下載
- mongodb下載MongoDB
- springboot框架（下）Spring Boot框架
- EditThisCookie下載Cookie
- ADB下載
- 蛋白質（下）
- PaddleDetection下載
- 函式下函式
- docker命令（下）Docker
- 下載速度
- 垃圾回收_下
- RxJS速成 (下)JS
- bin下的bpl 與 redist下的bpl 區別Redis
- 如何利用python原始碼下載進行下單？Python原始碼
- Linux環境下 RabbitMQ 的下載與安裝LinuxMQ
- CentOS7.3下載，CentOS7.3 iso下載CentOS
- windows下ftp定時執行批次下載檔案，windows下ftp定時執行批次下載檔案的一種方法WindowsFTP
- typora下載安裝以及notepad++下載安裝
- Ubuntu22.4環境下npm下載gdal失敗UbuntuNPM
- Python 中的單下劃線和雙下劃線Python
- 記錄一下 Windows 下搭建 Homestead 的兩大坑Windows
- 聊下近況-下崗待就業三個月就業
- Linux下使用Nginx做CDN伺服器下的配置LinuxNginx伺服器
- rust 語言試一下,記錄一下Rust