##方法：

//將另一個NSData加到原來的NSData後面
-(void)appendData:(NSData*)otherData

//將bytes直接加入NSData,參數為1.bytes的起始位置(要加&),2.bytes的長度
-(void)appendBytes:(const void*)bytes length:(NSUInteger)length

//截取其中某一段NSData
-(NSData*)subdataWithRange:(NSRange)range

//從你的NSData中copy某段bytes出來，存到你新建的buffer（要加&）中（存數值資料，而非NSData）
-(void)getBytes:(void*)buffer range:(NSRange)range

//從你的NSData中從頭copy某段指定長度的bytes出來，存到你新建的buffer（要加&）中（存數值資料，而非NSData）
-(void)getBytes:(void*)buffer length:(NSUInteger)length

##範例

//直接取得binary檔案

NSURL *imgPath = [[NSBundle mainBundle] URLForResource:@"yourBinary" withExtension:@"bin"];
NSString *stringPath = [imgPath absoluteString];
NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringPath]];

//要把NSData轉回NSNumber時(這裡是以short為範例)
short s;
[yourData getBytes:&s range:range];
NSNumber* stepCount = [NSNumber numberWithUnsignedShort:s];


// low level read method - read data while there is data and space available in the input buffer
- (void)_readData{
    uint8_t buf[EAD_INPUT_BUFFER_SIZE];
    while ([[_session inputStream] hasBytesAvailable]){
        NSInteger bytesRead = [[_session inputStream] read:buf maxLength:EAD_INPUT_BUFFER_SIZE];
        if (_readData == nil){
            _readData = [[NSMutableData alloc] init];
        }
        [_readData appendBytes:(void *)buf length:bytesRead];
        //NSLog(@"read %d bytes from input stream", bytesRead);
 }
    
    [[NSNotificationCenter defaultCenter] postNotificationName:EADSessionDataReceivedNotification object:self userInfo:nil];

    //清空_readData
    if( _readData ){
        [_readData setLength:0];
    }
}

// high level read method
// 這裡輸入的參數為你想要切的長度。

- (NSData *)readData:(NSUInteger)bytesToRead
{
    NSData *data = nil;
    if ([_readData length] >= bytesToRead)
    {
        NSRange range = NSMakeRange(0, bytesToRead);
        data = [_readData subdataWithRange:range];
        [_readData replaceBytesInRange:range withBytes:NULL length:0];
    }
    return data;
}

// get number of bytes read into local buffer

-(NSUInteger)readBytesAvailable{
    return [_readData length];

}

//自己寫的切封包

+ (NSArray*)splitDataIntoChunks:(NSData*)data size:(NSUInteger)bytesPerChunk{
    if(!data) return nil;
    NSMutableArray* array = [[NSMutableArray alloc]init];
    NSUInteger dataLength = [data length];
    NSUInteger chunkCount = 0;
    while (chunkCount < dataLength){
        NSRange range = NSMakeRange(chunkCount, bytesPerChunk);
        NSData* chunk = [data subdataWithRange:range];
        [array addObject:chunk];
        chunkCount += 2;
    }
    return array;
}

NSMutableParagraphStyle的部分属性：

typedef NS_ENUM(NSInteger, NSLineBreakMode) {/* What to do with long lines */  
    NSLineBreakByWordWrapping = 0,     /* Wrap at word boundaries, default */  
    NSLineBreakByCharWrapping,/* Wrap at character boundaries */  
    NSLineBreakByClipping,/* Simply clip */剪掉后面显示不了的部分  
    NSLineBreakByTruncatingHead,/* Truncate at head of line: "...wxyz" */头部分的内容以……方式省略  
    NSLineBreakByTruncatingTail,/* Truncate at tail of line: "abcd..." */结尾部分的内容以……方式省略  
    NSLineBreakByTruncatingMiddle/* Truncate middle of line:  "ab...yz" */中间部分的内容以……方式省略  
} NS_ENUM_AVAILABLE_IOS(6_0);  
  

typedef NS_ENUM(NSInteger, NSWritingDirection) {  
    NSWritingDirectionNatural       = -1,    // Determines direction using the Unicode Bidi Algorithm rules P2 and P3  
    NSWritingDirectionLeftToRight   =  0,    // Left to right writing direction 左到右的书写方向  
    NSWritingDirectionRightToLeft   =  1    // Right to left writing direction 右到左的书写方向  
} NS_ENUM_AVAILABLE_IOS(6_0);  
  

 //   NSParagraphStyleAttributeName 段落的风格（设置首行，行间距，对齐方式什么的）看自己需要什么属性，写什么  
    NSMutableParagraphStyle *paragraphStyle = [[NSMutableParagraphStyle alloc] init];  
    paragraphStyle.lineSpacing = 10;// 字体的行间距  
    paragraphStyle.firstLineHeadIndent = 20.0f;//首行缩进  
    paragraphStyle.alignment = NSTextAlignmentJustified;//（两端对齐的）文本对齐方式：（左，中，右，两端对齐，自然）  
    paragraphStyle.lineBreakMode = NSLineBreakByTruncatingTail;//结尾部分的内容以……方式省略 ( "...wxyz" ,"abcd..." ,"ab...yz")  
    paragraphStyle.headIndent = 20;//整体缩进(首行除外)  
    paragraphStyle.tailIndent = 20;//  
    paragraphStyle.minimumLineHeight = 10;//最低行高  
    paragraphStyle.maximumLineHeight = 20;//最大行高  
    paragraphStyle.paragraphSpacing = 15;//段与段之间的间距  
    paragraphStyle.paragraphSpacingBefore = 22.0f;//段首行空白空间/* Distance between the bottom of the previous paragraph (or the end of its paragraphSpacing, if any) and the top of this paragraph. */  
    paragraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;//从左到右的书写方向（一共??三种）  
    paragraphStyle.lineHeightMultiple = 15;/* Natural line height is multiplied by this factor (if positive) before being constrained by minimum and maximum line height. */  
    paragraphStyle.hyphenationFactor = 1;//连字属性 在iOS，唯一支持的值分别为0和1  
  
/* 
     NSFontAttributeName 字体大小 
     NSParagraphStyleAttributeName 段落的风格（设置首行，行间距，对齐方式什么的） 
     NSKernAttributeName 字间距 
     */  
    NSDictionary *attributes = @{  
                                 NSFontAttributeName:[UIFont systemFontOfSize:15],  
                                 NSParagraphStyleAttributeName:paragraphStyle,  
                                 NSKernAttributeName:@(10),  
                                                                
                                 };  
    textView.attributedText = [[NSAttributedString alloc] initWithString:textView.text attributes:attributes];

NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
paragraph.alignment = NSTextAlignmentJustified;//设置对齐方式
paragraph.lineBreakMode = NSLineBreakByWordWrapping;

NSAttributedString的初始化方法有
-initWithString:用String初始化，并没有Attributed信息。
-initWithAttributedString:用AttributedString去初始化。
-initWithString:Attributed:用string及attribute的dictionary来初始化。

下面这段代码可以查看ios中可用的字体，具体那些字体长什么样，可以查看字体册工具。

NSArray *familyArray = [UIFont familyNames];
for (id family in familyArray) {
printf(“%s\n”,[family cStringUsingEncoding:NSUTF8StringEncoding]);
NSArray *fontArray = [UIFont fontNamesForFamilyName:family];
for (id font in fontArray) {
printf(”   %s\n”,[font cStringUsingEncoding:NSUTF8StringEncoding]);
}
}

NSMutableParagraphStyle与NSParagraphStyle包括一下属性

1. alignment //对齐方式
2. firstLineHeadIndent //首行缩进
3. headIndent //缩进
4. tailIndent //尾部缩进
5. lineBreakMode //断行方式
6. maximumLineHeight //最大行高
7. minimumLineHeight //最低行高
8. lineSpacing //行距
9. paragraphSpacing //段距
10. paragraphSpacingBefore //段首空间
11. baseWritingDirection //句子方向
12. lineHeightMultiple //可变行高,乘因数。
13. hyphenationFactor //连字符属性

//   NSParagraphStyleAttributeName 段落的风格（设置首行，行间距，对齐方式什么的）看自己需要什么属性，写什么  
    NSMutableParagraphStyle *paragraphStyle = [[NSMutableParagraphStyle alloc] init];  
    paragraphStyle.lineSpacing = 10;// 字体的行间距  
    paragraphStyle.firstLineHeadIndent = 20.0f;//首行缩进  
    paragraphStyle.alignment = NSTextAlignmentJustified;//（两端对齐的）文本对齐方式：（左，中，右，两端对齐，自然）  
    paragraphStyle.lineBreakMode = NSLineBreakByTruncatingTail;//结尾部分的内容以……方式省略 ( "...wxyz" ,"abcd..." ,"ab...yz")  
    paragraphStyle.headIndent = 20;//整体缩进(首行除外)  
    paragraphStyle.tailIndent = 20;//  
    paragraphStyle.minimumLineHeight = 10;//最低行高  
    paragraphStyle.maximumLineHeight = 20;//最大行高  
    paragraphStyle.paragraphSpacing = 15;//段与段之间的间距  
    paragraphStyle.paragraphSpacingBefore = 22.0f;//段首行空白空间/* Distance between the bottom of the previous paragraph (or the end of its paragraphSpacing, if any) and the top of this paragraph. */  
    paragraphStyle.baseWritingDirection = NSWritingDirectionLeftToRight;//从左到右的书写方向（一共➡️三种）  
    paragraphStyle.lineHeightMultiple = 15;/* Natural line height is multiplied by this factor (if positive) before being constrained by minimum and maximum line height. */  
    paragraphStyle.hyphenationFactor = 1;//连字属性 在iOS，唯一支持的值分别为0和1  

具体AttributtedString属性的键值对如下：

 NSFontAttributeName                设置字体属性，默认值：字体：Helvetica(Neue) 字号：12
 NSForegroundColorAttributeNam      设置字体颜色，取值为 UIColor对象，默认值为黑色
 NSBackgroundColorAttributeName     设置字体所在区域背景颜色，取值为 UIColor对象，默认值为nil, 透明色
 NSLigatureAttributeName            设置连体属性，取值为NSNumber 对象(整数)，0 表示没有连体字符，1 表示使用默认的连体字符
 NSKernAttributeName                设定字符间距，取值为 NSNumber 对象（整数），正值间距加宽，负值间距变窄
 NSStrikethroughStyleAttributeName  设置删除线，取值为 NSNumber 对象（整数）
 NSStrikethroughColorAttributeName  设置删除线颜色，取值为 UIColor 对象，默认值为黑色
 NSUnderlineStyleAttributeName      设置下划线，取值为 NSNumber 对象（整数），枚举常量 NSUnderlineStyle中的值，与删除线类似
 NSUnderlineColorAttributeName      设置下划线颜色，取值为 UIColor 对象，默认值为黑色
 NSStrokeWidthAttributeName         设置笔画宽度，取值为 NSNumber 对象（整数），负值填充效果，正值中空效果
 NSStrokeColorAttributeName         填充部分颜色，不是字体颜色，取值为 UIColor 对象
 NSShadowAttributeName              设置阴影属性，取值为 NSShadow 对象
 NSTextEffectAttributeName          设置文本特殊效果，取值为 NSString 对象，目前只有图版印刷效果可用：
 NSBaselineOffsetAttributeName      设置基线偏移值，取值为 NSNumber （float）,正值上偏，负值下偏
 NSObliquenessAttributeName         设置字形倾斜度，取值为 NSNumber （float）,正值右倾，负值左倾
 NSExpansionAttributeName           设置文本横向拉伸属性，取值为 NSNumber （float）,正值横向拉伸文本，负值横向压缩文本
 NSWritingDirectionAttributeName    设置文字书写方向，从左向右书写或者从右向左书写
 NSVerticalGlyphFormAttributeName   设置文字排版方向，取值为 NSNumber 对象(整数)，0 表示横排文本，1 表示竖排文本
 NSLinkAttributeName                设置链接属性，点击后调用浏览器打开指定URL地址
 NSAttachmentAttributeName          设置文本附件,取值为NSTextAttachment对象,常用于文字图片混排
 NSParagraphStyleAttributeName      设置文本段落排版格式，取值为 NSParagraphStyle 对象

enum {
NSUnderlineStyleNone = 0×00,
NSUnderlineStyleSingle = 0×01,
};设置删除线。

##一、简介

###1、使用步骤

配合使用NSOperation和NSOperationQueue也能实现多线程编程

先将操作封装到一个NSOperation对象中
然后将NSOperation对象添加到NSOperationQueue中
系统会自动将NSOperationQueue中的NSOperation取出来
将取出的NSOperation封装的操作放到一条新线程中执行
###2、具体实现方法：

第一步：封装操作

封装操作的时候可以使用NSOperation的子类实现，因为NSOperation是抽象类，所以不能直接使用。

三种方式：

NSInvocationOperation
NSBlockOperation
自定义子类继承NSOperation，实现内部相应的方法
下面分别讲解三种方式：

1、NSInvocationOperation
创建NSInvocationOperation对象

- (id)initWithTarget:(id)target selector:(SEL)sel object:(id)arg;

调用start方法开始执行操作

- (void)start;
//一旦执行操作，就会调用target的sel方法

注意:
默认情况下，调用了start方法后并不会开一条新线程去执行操作，而是在当前线程同步执行操作
只有将NSOperation放到一个NSOperationQueue中，才会异步执行操作

2、创建NSBlockOperation对象

+ (id)blockOperationWithBlock:(void (^)(void))block;

通过addExecutionBlock:方法添加更多的操作

- (void)addExecutionBlock:(void (^)(void))block;

注意：只要NSBlockOperation封装的操作数 > 1，就会异步执行操作

3、自定义NSOperation
自定义NSOperation的步骤很简单
重写- (void)main方法，在里面实现想执行的任务
重写- (void)main方法的注意点：
自己创建自动释放池（因为如果是异步操作，无法访问主线程的自动释放池）
经常通过- (BOOL)isCancelled方法检测操作是否被取消，对取消做出响应
由于取消同样会继续执行当前正在执行的任务, 所以耗时操作需要手动判断是否已经取消

if (self.isCancelled) return;

第二步：添加任务奥队列中：
// 一般情况下, 在做企业开发时候,都会定义一个全局的自定义队列, 便于使用

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

NSOperationQueue的作用

NSOperation可以调用start方法来执行任务，但默认是同步执行的
如果将NSOperation添加到NSOperationQueue（操作队列）中，系统会自动异步执行NSOperation中的操作
添加操作到NSOperationQueue中

- (void)addOperation:(NSOperation *)op;
- (void)addOperationWithBlock:(void (^)(void))block;

设置最大并发数

- (NSInteger)maxConcurrentOperationCount;
- (void)setMaxConcurrentOperationCount:(NSInteger)cnt;

##3、队列的取消、暂停、恢复

- (void)cancelAllOperations;
// 取消队列中所有的任务的执行
// 取消和暂停一样, 是取消后面的任务, 不能取消当前正在执行的任务
// 注意: 取消是不可以恢复的

提示：也可以调用NSOperation的- (void)cancel方法取消单个操作
暂停和恢复队列

- (void)setSuspended:(BOOL)b;
// YES代表暂停队列，NO代表恢复队列
- (BOOL)isSuspended;
// 只要设置队列的suspended为YES, 那么就会暂停队列中其它任务的执行
// 也就是说不会再继续执行没有执行到得任务
// 只要设置队列的suspended为NO, 那么就会恢复队列中其它任务的执行
// 注意: 设置为暂停之后, 不会立即暂停
// 会继续执行当前正在执行的任务, 直到当前任务执行完毕, 就不会执行下一个任务了
// 也就是说, 暂停其实是暂停下一个任务, 而不能暂停当前任务
// 注意: 暂停是可以恢复的

##4、依赖

NSOperation之间可以设置依赖来保证执行顺序
比如一定要让操作A执行完后，才能执行操作B，可以这么写

[operationB addDependency:operationA]; // 操作B依赖于操作A

可以在不同queue的NSOperation之间创建依赖关系

##5、任务操作的监听

可以监听一个操作的执行完毕

- (void (^)(void))completionBlock;
- (void)setCompletionBlock:(void (^)(void))block;</code>

// 4.监听op4什么时候执行完毕
op4.completionBlock = ^{
    NSLog(@"op4中所有的操作都执行完毕了");
};

##具体使用介绍：
实例一：
NSBlockOperation简单使用，并添加任务

 //1. 封装任务
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        // 主线程
        NSLog(@"1---%@", [NSThread currentThread]);
    }];
    // 2.追加其它任务
    // 注意: 在没有队列的情况下, 如果给BlockOperation追加其它任务, 那么其它任务会在子线程中执行
    [op1 addExecutionBlock:^{
        NSLog(@"2---%@", [NSThread currentThread]);
    }];
    [op1 addExecutionBlock:^{
        NSLog(@"3---%@", [NSThread currentThread]);
    }];
    // 3.启动任务
    [op1 start];

实例二：

NSInvocationOperation的简单使用

// 1.封装任务
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
// 2.要想执行任务必须调用start
[op1 start];

实例三：

创建各种操作并添加到队列里面

// 1.创建队列
    /*
     GCD中有哪些队列:
     并发: 自己创建, 全局
     串行: 自己创建, 主队列
 
     NSOperationQueue:
     主队列: mainQueue
     自己创建: 会在子线程中执行
     */
 
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 2.创建任务
    // 只要是自己创建的队列, 就会在子线程中执行
    // 而且默认就是并发执行
    //第一种
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download1) object:nil];
    //第二种
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2 == %@", [NSThread currentThread]);
    }];
 
    // 注意: 如果是使用block来封装任务, 那么有一种更简便的方法
    // 只要利用队列调用addOperationWithBlock:方法, 系统内部会自动封装成一个NSBlockOperation然后再添加到队列中
    //第三种
    [queue addOperationWithBlock:^{
        NSLog(@"3 == %@", [NSThread currentThread]);
    }];
 
 
    // 3.添加任务到队列中
    // 只要将任务添加到队列中, 队列会自动调用start
    [queue addOperation:op1];
    [queue addOperation:op2];

实例四：

最大执行数量

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 自己创建的队列默认是并发,如果设置maxConcurrentOperationCount = 1,就是串行
// 注意: 不能设置为0, 如果设置为0就不行执行任务\
// 默认情况下maxConcurrentOperationCount = -1,是并行
// 在开发中并发数最多尽量不要超过5~6条
queue.maxConcurrentOperationCount = 0;

实例四：

线程间通讯

// 1.创建一个队列
    // 一般情况下, 在做企业开发时候, 都会定义一个全局的自定义队列, 便于使用
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
 
    // 2.添加一个操作下载第一张图片
    __block UIImage *image1 = nil;
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url  = [NSURL URLWithString:@"http://imgcache.mysodao.com/img2/M04/8C/74/CgAPDk9dyjvS1AanAAJPpRypnFA573_700x0x1.JPG"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        image1 = [UIImage imageWithData:data];
    }];
 
    // 3.添加一个操作下载第二张图片
    __block UIImage *image2 = nil;
     NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSURL *url  = [NSURL URLWithString:@"http://imgcache.mysodao.com/img1/M02/EE/B5/CgAPDE-kEtqjE8CWAAg9m-Zz4qo025-22365300.JPG"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        image2 = [UIImage imageWithData:data];
    }];
    // 4.添加一个操作合成图片
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        UIGraphicsBeginImageContext(CGSizeMake(200, 200));
        [image1 drawInRect:CGRectMake(0, 0, 100, 200)];
        [image2 drawInRect:CGRectMake(100, 0, 100, 200)];
        UIImage *res = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndImageContext();
 
        // 5.回到主线程更新UI
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            self.imageView.image = res;
        }];
    }];
 
    // 6.添加依赖
 
    [op3 addDependency:op1];
    [op3 addDependency:op2];
 
    // 7.添加操作到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];

GCD是iOS的一种底层多线程机制，今天总结一下GCD的常用API和概念，希望对大家的学习起到帮助作用。

##GCD队列的概念

在多线程开发当中，程序员只要将想做的事情定义好，并追加到DispatchQueue（派发队列）当中就好了。
派发队列分为两种，一种是串行队列（SerialDispatchQueue），一种是并行队列（ConcurrentDispatchQueue）。

一个任务就是一个block，比如，将任务添加到队列中的代码是：

dispatch_async(queue, block);

当给queue添加多个任务时，如果queue是串行队列，则它们按顺序一个个执行，同时处理的任务只有一个。
当queue是并行队列时，不论第一个任务是否结束，都会立刻开始执行后面的任务，也就是可以同时执行多个任务。
但是并行执行的任务数量取决于XNU内核，是不可控的。比如，如果同时执行10个任务，那么10个任务并不是开启10个线程，线程会根据任务执行情况复用，由系统控制。

##获取队列

系统提供了两个队列，一个是MainDispatchQueue，一个是GlobalDispatchQueue。
前者会将任务插入主线程的RunLoop当中去执行，所以显然是个串行队列，我们可以使用它来更新UI。
后者则是一个全局的并行队列，有高、默认、低和后台4个优先级。

它们的获取方式如下：

dispatch_queue_t queue = dispatch_get_main_queue();
dispatch queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRORITY_DEFAULT, 0)

###执行异步任务

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);     dispatch_async(queue, ^{ 
	//...
});

这个代码片段直接在子线程里执行了一个任务块。使用GCD方式任务是立即开始执行的
它不像操作队列那样可以手动启动，同样，缺点也是它的不可控性。

###令任务只执行一次

+ (id)shareInstance {      
+ static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
         _shareInstance = [[self alloc] init];
     }); 
 }

这种只执行一次且线程安全的方式经常出现在单例构造器当中。

##任务组

有时候，我们希望多个任务同时（在多个线程里）执行，再他们都完成之后，再执行其他的任务，
于是可以建立一个分组，让多个任务形成一个组，下面的代码在组中多个任务都执行完毕之后再执行后续的任务：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  
dispatch_group_t group = dispatch_group_create();  
dispatch_group_async(group, queue, ^{ NSLog(@"1"); });  
dispatch_group_async(group, queue, ^{ NSLog(@"2"); }); 
dispatch_group_async(group, queue, ^{ NSLog(@"3"); }); 
dispatch_group_async(group, queue, ^{ NSLog(@"4"); }); 
dispatch_group_async(group, queue, ^{ NSLog(@"5"); }); 

dispatch_group_notify(group, dispatch_get_main_queue(), ^{ 
	NSLog(@"done"); 
});

###延迟执行任务

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ 
	//... 
});

这段代码将会在10秒后将任务插入RunLoop当中。

dispatch_asycn和dispatch_sync

先前已经有过一个使用dispatch_async执行异步任务的一个例子，下面来看一段代码：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);     
dispatch_async(queue, ^{ 
	NSLog(@"1");  
});

NSLog(@"2");

这段代码首先获取了全局队列，也就是说，dispatch_async当中的任务被丢到了另一个线程里去执行，async在这里的含义是，当当前线程给子线程分配了block当中的任务之后，当前线程会立即执行，并不会发生阻塞，也就是异步的。那么，输出结果不是12就是21，因为我们没法把控两个线程RunLoop里到底是怎么执行的。

类似的，还有一个“同步”方法dispatch_sync，代码如下：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_sync(queue, ^{
NSLog(@"1");
}); 
NSLog(@"2");

这就意味着，当主线程将任务分给子线程后，主线程会等待子线程执行完毕，再继续执行自身的内容，那么结果显然就是12了。

需要注意的一点是，这里用的是全局队列，那如果把dispatch_sync的队列换成主线程队列会怎么样呢：

dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
	NSLog(@"1");
});

这段代码会发生死锁，因为：

1. 主线程通过dispatch_sync把block交给主队列后，会等待block里的任务结束再往下走自身的任务，
2. 而队列是先进先出的，block里的任务也在等待主队列当中排在它之前的任务都执行完了再走自己。

这种循环等待就形成了死锁。所以在主线程当中使用dispatch_sync将任务加到主队列是不可取的。

##创建队列

我们可以使用系统提供的函数获取主串行队列和全局并行队列，当然也可以自己手动创建串行和并行队列，代码为：

dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.Steak.GCD", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.Steak.GCD", DISPATCH_QUEUE_CONCURRENT);

在MRC下，手动创建的队列是需要释放的

dispatch_release(myConcurrentDispatchQueue);

手动创建的队列和默认优先级全局队列优先级等同，如果需要修改队列的优先级，需要：

dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.Steak.GCD", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t targetQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_set_target_queue(myConcurrentDispatchQueue, targetQueue);

上面的代码修改队列的优先级为后台级别，即与默认的后台优先级的全局队列等同。

##串行、并行队列与读写安全性

在向串行队列（SerialDispatchQueue）当中加入多个block任务后，一次只能同时执行一个block，如果生成了n个串行队列，并且向每个队列当中都添加了任务，那么系统就会启动n个线程来同时执行这些任务。

对于串行队列，正确的使用时机，是在需要解决数据/文件竞争问题时使用它。比如，我们可以令多个任务同时访问一块数据，这样会出现冲突，也可以把每个操作都加入到一个串行队列当中，因为串行队列一次只能执行一个线程的任务，所以不会出现冲突。

但是考虑到串行队列会因为上下文切换而拖慢系统性能，所以我们还是很期望采用并行队列的，来看下面的示例代码：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);    dispatch_async(queue, ^{
	//数据读取
});
dispatch_async(queue, ^{
	//数据读取2 
}); 
dispatch_async(queue, ^{
	//数据写入
});
dispatch_async(queue, ^{ 
	//数据读取3
});
dispatch_async(queue, ^{
	//数据读取4
});

显然，这5个操作的执行顺序是我们无法预期的，我们希望在读取1和读取2执行结束后，再执行写入，写入完成后再执行读取3和读取4。

为了实现这个效果，这里可以使用GCD的另一个API：

dispatch_barrier_async(queue, ^{
	//数据写入
});

这样就保证的写入操作的并发安全性。

对于没有数据竞争的并行操作，则可以使用并行队列（CONCURRENT）来实现。

##JOIN行为

CGD利用dispatch_group_wait来实现多个操作的join行为，代码如下：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);     dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
	sleep(0.5);
	NSLog(@"1"); 
});
dispatch_group_async(group, queue, ^{
	sleep(1.5);
	NSLog(@"2");
});
dispatch_group_async(group, queue, ^{
	sleep(2.5);
	NSLog(@"3");
});
NSLog(@"aaaaa");

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 2ull * NSEC_PER_SEC);
if (dispatch_group_wait(group, time) == 0) { 
 	NSLog(@"已经全部执行完毕");
}else {
	NSLog(@"没有执行完毕");

NSLog(@"bbbbb");

这里起了3个异步线程放在一个组里，之后通过dispatch_time_t创建了一个超时时间（2秒），程序之后行，立即输出了aaaaa，这是主线程输出的，当遇到dispatch_group_wait时，主线程会被挂起，等待2秒，在等待的过程当中，子线程分别输出了1和2，2秒时间达到后，主线程发现组里的任务并没有全部结束，然后输出了bbbbb。

在这里，如果超时时间设置得比较长（比如5秒），那么会在2.5秒时第三个任务结束后，立即输出bbbbb，也就是说，当组中的任务全部执行完毕时，主线程就不再被阻塞了。

如果希望永久等待下去，时间可以设置为DISPATCH_TIME_FOREVER。

##并行循环
类似于C#的PLINQ，OC也可以让循环并行执行，在GCD当中有一个dispatch_apply函数：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(20, queue, ^(size_t i) { 
	NSLog(@"%lu", i); 
});

这段代码让i并行循环了20次，如果内部处理的是一个数组，就可以实现对数组的并行循环了，它的内部是dispatch_sync的同步操作，所以在执行这个循环的过程当中，当前线程会被阻塞。

##暂停和恢复

使用dispatch_suspend(queue)可以暂停队列中任务的执行，使用dispatch_result(queue)可以继续执行被暂停的队列。

##关联对象:

###设置一个关联对象

void objc_setAssociatedObject(id object, void *key ,id value, objc_AssociationPolicy policy)

###获取关联对象

void objc_getAssociatedObject(id object, void *key)

###删除该对象所有的关联对象

void objc_removeAssociatedObjects(id object)

##消息传递

###向某个对象/父类 发送消息

objc_msgSend（Super）

##方法调配

###交换两个方法的实现

void method_exchangeImplementation(Method m1, Method m2)

###得到该法的指针

Method class_getInstanceMethod(Class aClass, SEL aSelector)

##动态创建对象
###创建新的类

Class objc_allocateClassPair(Class superclass, const char *name,size_t extraBytes)

###给类增加新的方法

BOOL class_addMethod(Class cls, SEL name, IMP imp,const char *types)

###注册新的类

void objc_registerClassPair(Class cls)

###获得对象的isa指针所指向的对象

Class object_getClass(id obj)

iOS的开发语言objective-c，它的真实面目是它不是真正的面向对象语言，而抽象理解为此而已。其实它就是C+，有个公式可以很好地诠释那就是

OC = C + Runtime; 接下来我们就好好讲讲在Runtime下的objc-class。准备资料,objc4-646/runtime。

##Class定义
###小小说明一下objc-api.h里的OBJC_ISA_AVAILABILITY:

/*介绍一下__attribute__((deprecated))的作用,__attribute是给函数、变量、类做属性说明的关键字，deprecated是弃用原先的进行兼容

若是__OBJC2__,原先的类，编译器发出警告*/

#if !defined(OBJC_ISA_AVAILABILITY)
#   if __OBJC2__
#       define OBJC_ISA_AVAILABILITY  __attribute__((deprecated))
#   else
#       define OBJC_ISA_AVAILABILITY  /* still available */
#   endif
#endif

typedef struct objc_method *Method;
typedef struct objc_ivar *Ivar;
typedef struct objc_category *Category;
typedef struct objc_property *objc_property_t;

###接下来就是runtime.h里的Class的定义:

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;//每个Class都有一个isa指针
     
#if !__OBJC2__
    Class super_class                                        OBJC2_UNAVAILABLE;//父类
    const char *name                                         OBJC2_UNAVAILABLE;//类名
    long version                                             OBJC2_UNAVAILABLE;//类版本
    long info                                                OBJC2_UNAVAILABLE;//!*!供运行期使用的一些位标识。如：CLS_CLASS (0x1L)表示该类为普通class; CLS_META(0x2L)表示该类为metaclass等(runtime.h中有详细列出)
    long instance_size                                       OBJC2_UNAVAILABLE;//实例大小
    struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;//存储每个实例变量的内存地址
    struct objc_method_list **methodLists                    OBJC2_UNAVAILABLE;//!*!根据info的信息确定是类还是实例，运行什么函数方法等
    struct objc_cache *cache                                 OBJC2_UNAVAILABLE;//缓存
    struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;//协议
#endif
     
} OBJC2_UNAVAILABLE;

###class初始化
Runtime的行为之一就是initialize。在程序运行过程中，它会在你程序中每个类调用一次initialize。这个调用的时间发生在你的类接收到消息之前，但是在它的超类接收到initialize之后。

//在苹果的官方Runtime中有个objc-initialize.m文件，进行解读
typedef struct _objc_initializing_classes {
    int classesAllocated;//类是否分配存在
    Class *metaclasses;//类的父类,如果没有父类那就是自身
} _objc_initializing_classes;//初始化一个对象_objc_initializing_classes
 
//将所有的类存储在静态链表中，以待接下来的接收和发送消息
static _objc_initializing_classes *_fetchInitializingClassList(BOOL create)
{
    _objc_pthread_data *data;
    //list为类链表
    _objc_initializing_classes *list;
    Class *classes;
     
    data = _objc_fetch_pthread_data(create);
    if (data == nil) return nil;
     
    //链表增加类节点
    list = data->initializingClasses;
    if (list == nil) {
        if (!create) {
            return nil;
        } else {
            list = (_objc_initializing_classes *)
            _calloc_internal(1, sizeof(_objc_initializing_classes));
            data->initializingClasses = list;
        }
    }
    //将创建的classes接在metaclasses后
    classes = list->metaclasses;
    if (classes == nil) {
        // If _objc_initializing_classes exists, allocate metaclass array,
        // even if create == NO.
        // Allow 4 simultaneous class inits on this thread before realloc.
        list->classesAllocated = 4;
        classes = (Class *)
        _calloc_internal(list->classesAllocated, sizeof(Class));
        list->metaclasses = classes;
    }
    return list;
}

###runtime下Class的各项操作(重要几个)

• add*(增加)

1. static IMP addMethod(Class cls, SEL name, IMP imp, const char *types, BOOL replace);//增加方法
2. BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types);//增加类方法
3. BOOL class_addIvar(Class cls, const char *name, size_t size,uint8_t alignment, const char *type);//增加实例变量
4. static BOOL class_addProperty(Class cls, const char *name,const objc_property_attribute_t *attrs, unsigned int count,BOOL replace);//增加属性

• replace*(修改)

1. IMP class_replaceMethod(Class cls, SEL name, IMP imp, const char *types); //修改方法
2. void class_replaceProperty(Class cls, const char *name,const objc_property_attribute_t *attrs, unsigned int n);//修改属性

• get*(获取)

1. static Class getClass(const char *name);//获取类
2. static ivar_t *getIvar(Class cls, const char *name);//获取类变量(static相当于“+“)
3. Method class_getInstanceMethod(Class cls, SEL sel);//获取实例方法
4. static Method class_getMethod(Class cls, SEL sel);;//获取类方法
5. static Protocol *getProtocol(const char *name);//增加协议

• set*(设置)

1. objc_class::setInitialized();//set的initialized初始化
2. static Class setSuperclass(Class cls, Class newSuper);//设置父类
3. 其他还有类似于 void *objc_destructInstance(id obj);//摧毁实例对象等等

###Class的重要函数

• get*(获取)

1. object_getClass(id obj);
2. IMP object_getMethodImplementation(id obj, SEL name);//获得实例方法实现
3. Ivar object_getInstanceVariable(id obj, const char *name, void **value)//获取实例属性

• set*(设置)

1. Class object_setClass(id obj, Class cls);
2. Ivar object_setInstanceVariable(id obj, const char *name, void *value);//设置实例属性
3. void object_setIvar(id obj, Ivar ivar, id value);//设置实例变量

• 其他

1. static void class_resolveClassMethod(Class cls, SEL sel, id inst);//动态添加类方法，不必在乎方法是否存在
2. static void class_resolveInstanceMethod(Class cls, SEL sel, id inst);//动态添加实现方法，不必在乎方法是否存在
3. unsigned class_createInstancesFromZone(Class cls, size_t extraBytes, void *zone,id *results, unsigned num_requested);//创建实例存储空间

• 消息转发

1. void instrumentObjcMessageSends(BOOL flag);//flag传入YES，运行时发送的所有消息都会打印到/tmp/msgSend-xxxx文件里了。

iOS app启动的方式有哪些：

1. 自己启动（用户手动点击启动）
2. urlscheme启动（关于urlScheme的详解点击打开链接）
3. 本地通知启动 （自己写的本地通知启动，蓝牙模块的启动，地理围栏的启动）
4. 远程通知启动 （后台服务器的推送通知）

在appdelegate.m文件中

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions

系统给的一些关于launchoption的字典里面的内容

UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsURLKey                   NS_AVAILABLE_IOS(3_0); // userInfo contains NSURL with launch URL
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsSourceApplicationKey     NS_AVAILABLE_IOS(3_0); // userInfo contains NSString with launch app bundle ID
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsRemoteNotificationKey    NS_AVAILABLE_IOS(3_0) __TVOS_PROHIBITED; // userInfo contains NSDictionary with payload
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsLocalNotificationKey     NS_AVAILABLE_IOS(4_0) __TVOS_PROHIBITED; // userInfo contains a UILocalNotification
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsAnnotationKey            NS_AVAILABLE_IOS(3_2); // userInfo contains object with annotation property list
UIKIT_EXTERN NSString *const UIApplicationProtectedDataWillBecomeUnavailable    NS_AVAILABLE_IOS(4_0);
UIKIT_EXTERN NSString *const UIApplicationProtectedDataDidBecomeAvailable       NS_AVAILABLE_IOS(4_0);
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsLocationKey              NS_AVAILABLE_IOS(4_0); // app was launched in response to a CoreLocation event.
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsNewsstandDownloadsKey    NS_AVAILABLE_IOS(5_0) __TVOS_PROHIBITED; // userInfo contains an NSArray of NKAssetDownload identifiers
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsBluetoothCentralsKey     NS_AVAILABLE_IOS(7_0); // userInfo contains an NSArray of CBCentralManager restore identifiers
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsBluetoothPeripheralsKey  NS_AVAILABLE_IOS(7_0); // userInfo contains an NSArray of CBPeripheralManager restore identifiers
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsShortcutItemKey          NS_AVAILABLE_IOS(9_0) __TVOS_PROHIBITED; // userInfo contains the UIApplicationShortcutItem used to launch the app.

// Key in options dict passed to application:[will | did]FinishLaunchingWithOptions and info for UIApplicationDidFinishLaunchingNotification
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsUserActivityDictionaryKey    NS_AVAILABLE_IOS(8_0); // Sub-Dictionary present in launch options when user activity is present
UIKIT_EXTERN NSString *const UIApplicationLaunchOptionsUserActivityTypeKey          NS_AVAILABLE_IOS(8_0); // Key in user activity dictionary for the activity type

UIKIT_EXTERN NSString *const UIApplicationOpenSettingsURLString NS_AVAILABLE_IOS(8_0);

// Keys for application:openURL:options:
UIKIT_EXTERN NSString *const UIApplicationOpenURLOptionsSourceApplicationKey NS_AVAILABLE_IOS(9_0);   // value is an NSString containing the bundle ID of the originating application
UIKIT_EXTERN NSString *const UIApplicationOpenURLOptionsAnnotationKey NS_AVAILABLE_IOS(9_0);   // value is a property-list typed object corresponding to what the originating application passed in UIDocumentInteractionController's annotation property
UIKIT_EXTERN NSString *const UIApplicationOpenURLOptionsOpenInPlaceKey NS_AVAILABLE_IOS(9_0);   // value is a bool NSNumber, set to YES if the file needs to be copied before use

如何判断如下:

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    
    
    //用户自己点击启动
    if(!launchOptions)
    {
        NSLog(@"用户点击app启动");
    }
    else
    {
        NSURL *url = [launchOptions objectForKey:UIApplicationLaunchOptionsURLKey];
        //app 通过urlscheme启动
        if (url) {
            NSLog(@"app 通过urlscheme启动 url = %@",url);
        }
        UILocalNotification *localNotification = [launchOptions objectForKey:UIApplicationLaunchOptionsLocalNotificationKey];
        //通过本地通知启动
        if(localNotification)
        {
            NSLog(@"app 通过本地通知启动 localNotification = %@",localNotification);
        }
        NSDictionary *remoteCotificationDic = [launchOptions objectForKey:UIApplicationLaunchOptionsRemoteNotificationKey];
        //远程通知启动
        if(remoteCotificationDic)
        {
            NSLog(@"app 通过远程推送通知启动 remoteCotificationDic = %@",remoteCotificationDic);
        }
        //位置变动的通知
        if(launchOptions[@"UIApplicationLaunchOptionsLocationKey"])
        {
            //写你的重新定位的代码
        }
    }
    
    
    
    
    return YES;
}