GCD

概念：

1、首先搞清楚四个最常用的术语

同步、异步、并发、串行

　　同步和异步主要影响：能不能开启新的线程

　　　　同步：只是在当前线程中执行任务，不具备开启新线程的能力

　　　　异步：可以在新的线程中执行任务，具备开启新线程的能力

　　并发和串行主要影响：任务的执行方式

　　　　并发：允许多个任务并发（同时）执行（并不是用来并发就能开线程，得要使用了异步线程）

　　　　串行：一个任务执行完毕后，再执行下一个任务

2、 任务和队列

　　核心概念

　　　　任务：执行什么操作

　　　　队列：用来存放任务

　　GCD使用的两个步骤

　　　　定制任务（你要干什么，耗时操作，你先确定）

　　　　确定想做的事情

　　将任务添加到队列中

　　　　GCD会自动将队列中的任务取出，放到对应的线程中执行

　　　　任务的取出遵循队列的FIFO原则：先进先出，后进后出

3、 执行任务

　　GCD中有2个用来执行任务的常用函数

　　　　GCD中有2个用来执行任务的常用函数　

dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
// queue：队列
// block：任务

　　　　用异步的方式执行任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

　　　　GCD中还有个用来执行任务的函数，在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行这个queue一定不能是全局的并发队列

dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

4、 队列的类型

　　GCD的队列可以分为2大类型

　　　　并发队列（Concurrent Dispatch Queue）

　　　　　　可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）

　　　　　　并发功能只有在异步（dispatch_async）函数下才有效。他们要合作才可以

　　　　串行队列（Serial Dispatch Queue）

　　　　　　让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

创建队列

1、 并发队列

　　使用dispatch_queue_create函数创建队列

dispatch_queue_t
dispatch_queue_create(const char *label, // 队列名称
dispatch_queue_attr t attr); // 队列的类型

　　穿件并发队列

dispatch_queue_t queue = dispatch_queue_create("com.baidu.queue", DISPATCH_QUEUE_CONCURRENT);
//  CONCURRENT并发

　　GCD默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建，你就不需要手动创建了

dispatch_queue_t dispatch_get_global_queue(
dispatch_queue_priority_t priority, // 队列的优先级
unsigned long flags); // 此参数暂时无用，用0即可

　　获得全局并发队列，它会自动给你创建线程

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

　　全局并发队列的优先级

#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

2、 串行队列

　　GCD中获得串行有2种途径

　　　　使用dispatch_queue_create函数创建串行队列

// 创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）
dispatch_queue_t queue = dispatch_queue_create("com.baidu.queue", NULL);

　　使用主队列（跟主线程相关联的队列）

　　　　主队列是GCD自带的一种特殊的串行队列

　　　　放在主队列中的任务，都会放到主线程中执行

　　　　使用dispatch_get_main_queue()获得主队列

dispatch_queue_t queue = dispatch_get_main_queue();

线程间通信示例

　　从子线程回到主线程

dispatch_async(
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行耗时的异步操作...
      dispatch_async(dispatch_get_main_queue(), ^{
        // 回到主线程，执行UI刷新操作
        });
});

　　栅栏，拦住你先，虽然是异步的。但是它可以保证先执行前面的（谁先谁后我不管），再执行自己，再执行后面的（谁先谁后我不管）

　　用全局的异步队列不行

　　在barrier前定制的任务先执行，再执行barrier，再执行后面的任务

延时执行

　　iOS常见的延时执行

　　　　调用NSObject的方法

[self performSelector:@selector(run) withObject:nil afterDelay:2.0];
// 2秒后再调用self的run方法

　　　　使用GCD函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 2秒后执行这里的代码...
    //  默认在主线程执行，你也可以并发，在子线程执行
});

　　　　使用NSTimer

[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:NO];

单例

　　使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次，苹果自己写单例也是这么写的。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 只执行1次的代码(这里面默认是线程安全的)
});
//  适合做资源的加载，但是和懒加载不同，它一旦加载，加载一次，别人就不能加载，整个程序哦，全局性

快速迭代

　　使用dispatch_apply函数能进行快速迭代遍历

dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
    // 执行10次代码，index顺序不确定
    //  和for循环不同，不是有序的
    //  它是同时并发遍历，一起做事情，快速遍历迭代
    //  比如剪切图片的例子
});

队列租

　　有这么1种需求

　　　　首先：分别异步执行2个耗时的操作

　　　　其次：等2个异步操作都执行完毕后，再回到主线程执行操做

　　　　如果想要快速高效地实现上述需求，可以考虑用队列组

dispatch_group_t group =  dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 等前面的异步操作都执行完毕后，回到主线程...
});

　　　　在XMGPerson.h文件中

#import <Foundation/Foundation.h>

@interface XMGPerson : NSObject
/** 书本 */
@property (nonatomic, strong) NSArray *books;
@end

　　　　在XMGPerson.m文件中

#import "XMGPerson.h"

@implementation XMGPerson
- (NSArray *)books
{
    if (_books == nil) {
        _books = @[@"1分钟突破iOS开发", @"5分钟突破iOS开发"];
    }

//    static dispatch_once_t onceToken;
//    dispatch_once(&onceToken, ^{
//        _books = @[@"1分钟突破iOS开发", @"5分钟突破iOS开发"];
//    });

    return _books;
}
@end

　　　　在ViewController.m文件中

#import "ViewController.h"
#import "XMGPerson.h"

@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIImageView *imageView;
/** 图片1 */
@property (nonatomic, strong) UIImage *image1;
/** 图片2 */
@property (nonatomic, strong) UIImage *image2;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    XMGPerson *person1 = [[XMGPerson alloc] init];
    XMGPerson *person2 = [[XMGPerson alloc] init];
    XMGPerson *person3 = [[XMGPerson alloc] init];
    XMGPerson *person4 = [[XMGPerson alloc] init];

//    XMGPerson *p1 = [[XMGPerson alloc] init];
//    NSLog(@"%@", p1.books);
//
//    XMGPerson *p2 = [[XMGPerson alloc] init];
//    NSLog(@"%@", p2.books);
}

void download(void * data)
{

}

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
//    dispatch_async(<#dispatch_queue_t queue#>, <#^(void)block#>);
//    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//    dispatch_async_f(queue, NULL, download);

    [self group];
}

- (void)group
{

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 创建一个队列组
    dispatch_group_t group = dispatch_group_create();

    // 1.下载图片1
    dispatch_group_async(group, queue, ^{
        // 图片的网络路径
        NSURL *url = [NSURL URLWithString:@"http://img.pconline.com.cn/images/photoblog/9/9/8/1/9981681/200910/11/1255259355826.jpg"];

        // 加载图片
        NSData *data = [NSData dataWithContentsOfURL:url];

        // 生成图片
        self.image1 = [UIImage imageWithData:data];
    });

    // 2.下载图片2
    dispatch_group_async(group, queue, ^{
        // 图片的网络路径
        NSURL *url = [NSURL URLWithString:@"http://pic38.nipic.com/20140228/5571398_215900721128_2.jpg"];

        // 加载图片
        NSData *data = [NSData dataWithContentsOfURL:url];

        // 生成图片
        self.image2 = [UIImage imageWithData:data];
    });
    //  可以用barrier，先做前面两个，再做后面的任务
    //  这里用队列组，前面的任务都放进自己的一个组，你的队列属于自己的组，前面两个组不管你谁先执行，都执行完后，再执行dispatch_group_notify里面的东西
    // 3.将图片1、图片2合成一张新的图片
    //  图片合成用绘图技术
    dispatch_group_notify(group, queue, ^{
        // 开启新的图形上下文
        UIGraphicsBeginImageContext(CGSizeMake(100, 100));

        // 绘制图片
        [self.image1 drawInRect:CGRectMake(0, 0, 50, 100)];
        [self.image2 drawInRect:CGRectMake(50, 0, 50, 100)];

        // 取得上下文中的图片
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();

        // 结束上下文
        UIGraphicsEndImageContext();

        // 回到主线程显示图片
        dispatch_async(dispatch_get_main_queue(), ^{
            // 4.将新图片显示出来
            self.imageView.image = image;
        });
    });
}

/**
 * 快速迭代
 */
- (void)apply
{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSString *from = @"/Users/xiaomage/Desktop/From";
    NSString *to = @"/Users/xiaomage/Desktop/To";
    //  这里剪切文件完全可以同时进行，用子线程包起来

    NSFileManager *mgr = [NSFileManager defaultManager];
    NSArray *subpaths = [mgr subpathsAtPath:from];

    dispatch_apply(subpaths.count, queue, ^(size_t index) {
        NSString *subpath = subpaths[index];
        NSString *fromFullpath = [from stringByAppendingPathComponent:subpath];
        NSString *toFullpath = [to stringByAppendingPathComponent:subpath];
        // 剪切
        [mgr moveItemAtPath:fromFullpath toPath:toFullpath error:nil];

        NSLog(@"%@---%@", [NSThread currentThread], subpath);
    });
}

/**
 * 传统文件剪切
 */
- (void)moveFile
{
    NSString *from = @"/Users/xiaomage/Desktop/From";
    NSString *to = @"/Users/xiaomage/Desktop/To";

    NSFileManager *mgr = [NSFileManager defaultManager];
    NSArray *subpaths = [mgr subpathsAtPath:from];

    for (NSString *subpath in subpaths) {
        NSString *fromFullpath = [from stringByAppendingPathComponent:subpath];
        NSString *toFullpath = [to stringByAppendingPathComponent:subpath];
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            // 剪切
            [mgr moveItemAtPath:fromFullpath toPath:toFullpath error:nil];
        });
    }
}

- (void)once
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"------run");
    });
}

/**
 * 延迟执行
 */
- (void)delay
{
    NSLog(@"touchesBegan-----");
    //    [self performSelector:@selector(run) withObject:nil afterDelay:2.0];

    //    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    //        NSLog(@"run-----");
    //    });

    [NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(run) userInfo:nil repeats:NO];
}

- (void)run
{
    NSLog(@"run-----");
}

- (void)barrier
{
    dispatch_queue_t queue = dispatch_queue_create("12312312", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        NSLog(@"----1-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----2-----%@", [NSThread currentThread]);
    });

    dispatch_barrier_async(queue, ^{
        NSLog(@"----barrier-----%@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"----3-----%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"----4-----%@", [NSThread currentThread]);
    });
}

@end

重点：

单例模式--是一种设计模式

　　单例模式的作用

　　　　可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问（person，保证它永远只有一个对象）

　　　　从而方便地控制了实例个数，并节约系统资源（节约内存）

　　单例模式的使用场合

　　　　在整个应用程序中，共享一份资源（这份资源只需要创建初始化1次）（在哪里都能访问）

　　ARC中，单例模式的实现

　　在.m中保留一个全局的static的实例

static id _instance;
//  防止外界把你清空

　　重写allocWithZone:方法，在这里创建唯一的实例（注意线程安全），不能让他创建几次吧，once只保证一次，而且once保证线程安全```objc

(instancetype)allocWithZone:(struct _NSZone *)zone
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{

  _instance = [super allocWithZone:zone];
});
return _instance;
}

　　提供1个类方法让外界访问唯一的实

+ (instancetype)sharedInstance
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[self alloc] init];
    });
    return _instance;
}

实现copyWithZone:方法
- (id)copyWithZone:(struct _NSZone *)zone
{
    return _instance;
}

　　在ViewController.m文件中

#import "ViewController.h"
#import "XMGPerson.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

//    XMGPerson *person1 = [[XMGPerson alloc] init];
//    person1.name = @"jack";
//
//    XMGPerson *person2 = [[XMGPerson alloc] init];
//    XMGPerson *person3 = [[XMGPerson alloc] init];
//    XMGPerson *person4 = [[XMGPerson alloc] init];

//    NSLog(@"%p %p %p %p", person1, person2, person3, person4);内存地址不一样，所以重写alloc方法
//    NSLog(@"%@", person3.name);

//    NSLog(@"%@ %@", [XMGPerson sharedPerson], [XMGPerson sharedPerson]);
}

@end

　　在XMGPerson.h文件中

#import <Foundation/Foundation.h>

@interface XMGPerson : NSObject
/** 名字 */
@property (nonatomic, strong) NSString *name;

+ (instancetype)sharedPerson;
@end

　　在XMGPerson.m文件中

#import "XMGPerson.h"

@interface XMGPerson() <NSCopying>

@end

@implementation XMGPerson

static XMGPerson *_person;
//  防止别人访问。下划线是区别别的变量

+ (instancetype)allocWithZone:(struct _NSZone *)zone
{
      //  只会调一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _person = [super allocWithZone:zone];
        //  只调用一次，一次内存使用，只分配一次内存
        //  准确的是alloc内部会调用allocWithZone:zone，所以重写它
    });
    return _person;
}

+ (instancetype)sharedPerson
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _person = [[self alloc] init];
    });
    return _person;
}

- (id)copyWithZone:(NSZone *)zone
{
    return _person;
}
@end

　　在XMGCar.h文件中

#import <Foundation/Foundation.h>

@interface XMGCar : NSObject
+ (instancetype)sharedCar;
@end

　　在XMGCar.m文件中

#import "XMGCar.h"

@interface XMGCar() // <NSCopying>

@end

@implementation XMGCar

static XMGCar *_car;

+ (instancetype)allocWithZone:(struct _NSZone *)zone
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _car = [super allocWithZone:zone];
    });
    return _car;
}

+ (instancetype)sharedCar
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _car = [[self alloc] init];
    });
    return _car;
}

- (id)copyWithZone:(NSZone *)zone
{
    return _car;
}
@end

• 步骤
• 首先，在.m文件的实现部分搞一个实例static XMGCar *_car;在本文件才能访问的全局变量，范围是有限的，本文件
• 重写allocWithZone，目的是外面调用一千次已完成alloc，我们只返回同一个对象，用dispatch_once，调用我们_car = [super allocWithZone:zone];，再返回return _car;所以外面调用alloc都是返回的同一个对象
• 然后别人老师调用alloc，肯定不方便，所以我们要在.h文件在提供一个非常简便的方法+ (instancetype)sharedCar;给别人用。 
• 来到.m文件中，也是dispatch_once，保证它只alloc] init一次，因为别人调用你的share方法肯定是要拿到一个能用的方法，返回return _car;而且我们的alloc内部又会调到里面去，所以不用管
• 为了严谨起见，防止以后你要用到copy，假如别人真的不小心用到copy，会产生一个新的对象，所以严谨起见，告诉人家你以后要拷贝对象要返回的是同一个对象copyWithZone
• 前面两个是类方法，最后一个是对象方法
• 假如我项目中有十个类要实现单例，你是不是感觉都差不多，而且可以让他们看起来基本相似