GCD&&单粒

最新推荐文章于 2017-09-01 18:02:00 发布

JH_1995

最新推荐文章于 2017-09-01 18:02:00 发布

阅读量356

点赞数 1

分类专栏：多线程文章标签：线程 gcd

本文链接：https://blog.csdn.net/JH_1995/article/details/50628511

版权

多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

GCD基本思想

GCD的基本思想是就将操作放在队列中去执行
- 操作使用Blocks定义
- 队列负责调度任务执行所在的线程以及具体的执行时间
- 队列的特点是先进先出(FIFO)的，新添加至对列的操作都会排在队尾

GCD中的专用术语

同步函数和异步函数主要影响：能不能开启新的线程
- 同步函数：只是在当前线程中执行任务，不具备开启新线程的能力
- 异步函数：可以在新的线程中执行任务，具备开启新线程的能力(特殊情况：在主队列中不会开启新线程)
并发队列和串行队列主要影响：任务的执行方式
- 并发队列：允许多个任务并发（同时）执行
- 穿行队列：一个任务执行完毕后，再执行下一个任务

同步函数 && 异步函数的小差别

- (void)syncConcurrent
{
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    // 2.将任务加入队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@", [NSThread currentThread]);
    });

    NSLog(@"syncConcurrent--------end");// 先打印上面的，在打印这一句
}

- (void)asyncConcurrent
{
    // 1.获得全局的并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    // 2.将任务加入队列
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"1-----%@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"2-----%@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<10; i++) {
            NSLog(@"3-----%@", [NSThread currentThread]);
        }
    });

    NSLog(@"asyncConcurrent--------end");// 先打印这一句，再打印上面的
//    dispatch_release(queue);
}

NSLog(@”syncConcurrent——–end”);
NSLog(@”asyncConcurrent——–end”);
明白上面两行都是什么时候调用
同步函数：任务加入队列后，立刻执行
异步函数：任务加入队列后，等会执行，可以理解为asyncConcurrent函数执行完，在执行任务

串行队列&&主队列

GCD中获得串行队列有两种途径
使用dispatch_queue_create函数创建串行队列

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

dispatch_queue_t queue = dispatch_queue_create("AHUAN.queue", NULL);
// 同步操作不会新建线程、操作顺序执行（一般不用）
dispatch_sync(queue , ^{
    NSLog(@"串行同步 %@", [NSThread currentThread]);
});

// 异步操作会新建一个线程、操作顺序执行（非常有用！）场景：既不影响主线程，又需要顺序执行的操作！
dispatch_async(queue , ^{
    NSLog(@"串行异步 %@", [NSThread currentThread]);
});

使用主队列（跟住线程相关联的队列）
- 主队列是GCD自带的一种特殊的串行队列
- 放在主队列中的任务，都会放到主线程中
- 使用dispatch_get_main_queue() 获得主队列

// 每一个应用程序对应唯一一个主队列，直接GET即可,在多线程开发中，使用主队列更新UI
dispatch_queue_t queue = dispatch_get_main_queue();

// 主队列中的操作都应该在主线程上顺序执行的，不存在异步的概念
dispatch_async(queue, ^{
    NSLog(@"主队列异步 %@", [NSThread currentThread]);
});

// 主队列中添加的同步操作永远不会被执行，会死锁
dispatch_sync(queue, ^{
    NSLog(@"主队列同步 %@", [NSThread currentThread]);
});

并发队列&&全局队列

GCD中获得并发队列也有两种途径
手动创建并发队列

dispatch_queue_t queue = dispatch_queue_create("cn.itcast.demoqueue", DISPATCH_QUEUE_CONCURRENT);

// 同步操作不会新建线程,操作顺序执行
dispatch_sync(queue, ^{
    NSLog(@"并行同步 %@", [NSThread currentThread]);
});

// 异步操作会新建多个线程、操作无序执行（有用，容易出错！）
// 队列前如果有其他任务，会等待前面的任务完成之后再执行
// 场景：既不影响主线程，又不需要顺序执行的操作！

dispatch_async(queue, ^{
    NSLog(@"并行异步 %@", [NSThread currentThread]);
});

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

// 全局队列是系统的，直接拿过来（GET）用就可以
// 与并行队列类似
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
// 优先级 0 就代表 DISPATCH_QUEUE_PRIORITY_DEFAULT

这里写图片描述

不同队列中嵌套dispatch_sync的结果

// 全局队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 并行队列，都在主线程上执行，不会死锁
dispatch_queue_t q = dispatch_queue_create("AHUNA.queue",DISPATCH_QUEUE_CONCURRENT);

// 串行队列，会死锁，但是会执行嵌套同步操作之前的代码
dispatch_queue_t q = dispatch_queue_create("AHUNA.queue", DISPATCH_QUEUE_SERIAL);

// 直接死锁
dispatch_queue_t q = dispatch_get_main_queue();
dispatch_sync(q, ^{
    NSLog(@"同步任务 %@", [NSThread currentThread]);
    dispatch_sync(q, ^{
        NSLog(@"同步任务 %@", [NSThread currentThread]);
    });
});

线程间的通信示例

从子线程回到主线程

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

GCD常用函数

执行任务的函数dispatch_barrier_async

执行任务的函数

    dispatch_barrier_async(<#dispatch_queue_t queue#>, ^{
        <#code#>
    })

在这之前的任务结束后它才执行，而且它后面的任务等它执行完之后才会执行
这个queue不能是全局的并发队列，可以是我们自己创建的并发队列

一次性代码dispatch_once

确保某段代码在程序运行过程中只被执行1次

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
       // 这里面的代码整个程序只执行一次（这里面默认是线程安全的）
    });

延时执行

使用GCD函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 2秒后执行这里的代码...
});

调用NSObject的方法

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

使用NSTimer

[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(run) userInfo:nil repeats:NO];
// 2秒后在调用self的run方法

快速迭代

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

// size_t iterations代表执行多少次
dispatch_apply(<#size_t iterations#>, <#dispatch_queue_t queue#>, ^(size_t index) {
    <#code#>
    // index顺序不确定
});

组队列

// 分别异步执行两个耗时的操作（下载图片），等2个异步操作都执行完毕后，再异步执行一个耗时操作（合成图片）
// 然后在回到主线程中刷新UI界面

    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];
    });

    // 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;
        });
    });

单粒模式

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

// 重写allocWithZone:方法，在这里创建一个唯一的实例（注意线程安全）
+(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;
}

JH_1995

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
GCD&&单粒

GCD基本思想GCD的基本思想是就将操作放在队列中去执行操作使用Blocks定义队列负责调度任务执行所在的线程以及具体的执行时间队列的特点是先进先出(FIFO)的，新添加至对列的操作都会排在队尾GCD中的专用术语同步函数和异步函数主要影响：能不能开启新的线程同步函数：只是在当前线程中执行任务，不具备开启新线程的能力异步函数：可以在新的线程中执行任务，具备开启新线程的能力(特殊情况：在
复制链接

扫一扫