CocoaAsyncSocket源码Read(一)

正文：

一.浅析Read读取，并阐述数据从socket到用户手中的流程

大家用过这个框架就知道，我们每次读取数据之前都需要主动调用这么一个Read方法：

[gcdSocket readDataWithTimeout:-1 tag:110];

设置一个超时和tag值，这样我们就可以在这个超时的时间里，去读取到达当前socket的数据了。

那么本篇Read就从这个方法开始说起，我们点进框架里，来到这个方法：

- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag

{

     [self readDataWithTimeout:timeout buffer:nil bufferOffset:0 maxLength:0 tag:tag];

}

- (void)readDataWithTimeout:(NSTimeInterval)timeout

                     buffer:(NSMutableData *)buffer

               bufferOffset:(NSUInteger)offset

                        tag:(long)tag

{

     [self readDataWithTimeout:timeout buffer:buffer bufferOffset:offset maxLength:0 tag:tag];

}

//用偏移量 maxLength 读取数据
- (void)readDataWithTimeout:(NSTimeInterval)timeout

                     buffer:(NSMutableData *)buffer

               bufferOffset:(NSUInteger)offset

                  maxLength:(NSUInteger)length

                        tag:(long)tag

{
if (offset > [buffer length]) {
LogWarn(@"Cannot read: offset > [buffer length]");
return;

     }


     GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer

                                                               startOffset:offset

                                                                 maxLength:length

                                                                   timeout:timeout

                                                                readLength:0

                                                                terminator:nil

                                                                       tag:tag];

dispatch_async(socketQueue, ^{ @autoreleasepool {

LogTrace();

if ((flags & kSocketStarted) && !(flags & kForbidReadsWrites))

          {
//往读的队列添加任务，任务是包的形式

               [readQueue addObject:packet];

               [self maybeDequeueRead];

          }

     }});

}

这个方法很简单。最终调用，去创建了一个GCDAsyncReadPacket类型的对象packet，简单来说这个对象是用来标识读取任务的。然后把这个packet对象添加到读取队列中。然后去调用:

[self maybeDequeueRead];

去从队列中取出读取任务包，做读取操作。

还记得我们之前Connect篇讲到的GCDAsyncSocket这个类的一些属性，其中有这么一个：

//当前这次读取数据任务包

GCDAsyncReadPacket *currentRead;

//初始化
- (id)initWithData:(NSMutableData *)d

       startOffset:(NSUInteger)s

         maxLength:(NSUInteger)m

           timeout:(NSTimeInterval)t

        readLength:(NSUInteger)l

        terminator:(NSData *)e

               tag:(long)i;

//确保容器大小给多余的长度
- (void)ensureCapacityForAdditionalDataOfLength:(NSUInteger)bytesToRead;
////预期中读的大小，决定是否走preBuffer
- (NSUInteger)optimalReadLengthWithDefault:(NSUInteger)defaultValue shouldPreBuffer:(BOOL *)shouldPreBufferPtr;
//读取指定长度的数据
- (NSUInteger)readLengthForNonTermWithHint:(NSUInteger)bytesAvailable;

//上两个方法的综合
- (NSUInteger)readLengthForTermWithHint:(NSUInteger)bytesAvailable shouldPreBuffer:(BOOL *)shouldPreBufferPtr;

//根据一个终结符去读数据，直到读到终结的位置或者最大数据的位置，返回值为该包的确定长度
- (NSUInteger)readLengthForTermWithPreBuffer:(GCDAsyncSocketPreBuffer *)preBuffer found:(BOOL *)foundPtr;
////查找终结符，在prebuffer之后，返回值为该包的确定长度
- (NSInteger)searchForTermAfterPreBuffering:(ssize_t)numBytes;

//让读任务离队，开始执行这条读任务
- (void)maybeDequeueRead

{
LogTrace();
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");

// If we're not currently processing a read AND we have an available read stream

//如果当前读的包为空，而且flag为已连接
if ((currentRead == nil) && (flags & kConnected))

    {
//如果读的queue大于0 （里面装的是我们封装的GCDAsyncReadPacket数据包）
if ([readQueue count] > 0)

        {
// Dequeue the next object in the write queue
//使得下一个对象从写的queue中离开

//从readQueue中拿到第一个写的数据

            currentRead = [readQueue objectAtIndex:0];
//移除

            [readQueue removeObjectAtIndex:0];

//我们的数据包，如果是GCDAsyncSpecialPacket这种类型，这个包里装了TLS的一些设置
//如果是这种类型的数据，那么我们就进行TLS
if ([currentRead isKindOfClass:[GCDAsyncSpecialPacket class]])

            {
LogVerbose(@"Dequeued GCDAsyncSpecialPacket");

// Attempt to start TLS
//标记flag为正在读取TLS

                flags |= kStartingReadTLS;

// This method won't do anything unless both kStartingReadTLS and kStartingWriteTLS are set
//只有读写都开启了TLS,才会做TLS认证

                [self maybeStartTLS];

            }
else

            {
LogVerbose(@"Dequeued GCDAsyncReadPacket");

// Setup read timer (if needed)
//设置读的任务超时，每次延时的时候还会调用 [self doReadData];

                [self setupReadTimerWithTimeout:currentRead->timeout];

// Immediately read, if possible
//读取数据

                [self doReadData];

            }

        }

//读的队列没有数据，标记flag为，读了没有数据则断开连接状态
else if (flags & kDisconnectAfterReads)

        {
//如果标记有写然后断开连接
if (flags & kDisconnectAfterWrites)

            {
//如果写的队列为0，而且写为空
if (([writeQueue count] == 0) && (currentWrite == nil))

                {
//断开连接

                    [self closeWithError:nil];

                }

            }
else

            {
//断开连接

                [self closeWithError:nil];

            }

        }
//如果有安全socket。
else if (flags & kSocketSecure)

        {

            [self flushSSLBuffers];

//如果可读字节数为0
if ([preBuffer availableBytes] == 0)

            {
//
if ([self usingCFStreamForTLS]) {
// Callbacks never disabled

                }
else {
//重新恢复读的source。因为每次开始读数据的时候，都会挂起读的source

                    [self resumeReadSource];

                }

            }

        }

    }

}