GCD

最新推荐文章于 2023-03-16 17:10:01 发布
最新推荐文章于 2023-03-16 17:10:01 发布
阅读量519 收藏
点赞数

GCD的介绍有另外一篇博客专门写了下，需要看的可以点击以下传送门GCD线程死锁解锁案例分析，这里主要记录下基本的API使用以及两种单例的创建方式

1.GCD同步异步并发串行排列组合的集中基本形式


/*
 *  异步串行   --->       不阻塞当前线程，会开多一条线程，在这个线程中是串行执行的
 */
- (void)asynchSerial
{
    // 全局并发队列
    //    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    // 自定义并发队列
    dispatch_queue_t queue1 = dispatch_queue_create("COM.MKJ.COM", DISPATCH_QUEUE_SERIAL);

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

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

    dispatch_async(queue1, ^{
        NSLog(@"------3,%@",[NSThread currentThread]);
    });
    NSLog(@"asynchSerial------end");
//    2016-12-21 09:34:16.222 GCDBasicAPI[1137:38266] asynchSerial------end
//    2016-12-21 09:34:16.222 GCDBasicAPI[1137:38300] ------1,<NSThread: 0x60000007a640>{number = 3, name = (null)}
//    2016-12-21 09:34:16.223 GCDBasicAPI[1137:38300] ------2,<NSThread: 0x60000007a640>{number = 3, name = (null)}
//    2016-12-21 09:34:16.223 GCDBasicAPI[1137:38300] ------3,<NSThread: 0x60000007a640>{number = 3, name = (null)}

}


/*
 *  同步串行   --->       阻塞当前线程，不开多条线程，在当前线程执行，顺序执行
 */
- (void)synchSerial
{
    // 全局并发队列
    //    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    // 自定义并发队列
    dispatch_queue_t queue1 = dispatch_queue_create("COM.MKJ.COM", DISPATCH_QUEUE_SERIAL);

    dispatch_sync(queue1, ^{
        NSLog(@"------1,%@",[NSThread currentThread]);
    });

    dispatch_sync(queue1, ^{
        NSLog(@"------2,%@",[NSThread currentThread]);
    });

    dispatch_sync(queue1, ^{
        NSLog(@"------3,%@",[NSThread currentThread]);
    });
    NSLog(@"synchSerial------end");
//    2016-12-21 09:32:25.878 GCDBasicAPI[1117:36348] ------1,<NSThread: 0x600000075700>{number = 1, name = main}
//    2016-12-21 09:32:25.878 GCDBasicAPI[1117:36348] ------2,<NSThread: 0x600000075700>{number = 1, name = main}
//    2016-12-21 09:32:25.879 GCDBasicAPI[1117:36348] ------3,<NSThread: 0x600000075700>{number = 1, name = main}
//    2016-12-21 09:32:25.879 GCDBasicAPI[1117:36348] synchSerial------end

}




/*
 *  同步并发   --->       阻塞当前线程，不开多条线程，在当前线程执行，顺序执行
 */
- (void)synchConcurrent
{
    // 全局并发队列
    //    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    // 自定义并发队列
    dispatch_queue_t queue1 = dispatch_queue_create("COM.MKJ.COM", DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(queue1, ^{
        NSLog(@"------1,%@",[NSThread currentThread]);
    });

    dispatch_sync(queue1, ^{
        NSLog(@"------2,%@",[NSThread currentThread]);
    });

    dispatch_sync(queue1, ^{
        NSLog(@"------3,%@",[NSThread currentThread]);
    });
    NSLog(@"synchConcurrent------end");
//    2016-12-21 09:29:47.575 GCDBasicAPI[1071:33607] ------1,<NSThread: 0x60000006b900>{number = 1, name = main}
//    2016-12-21 09:29:47.575 GCDBasicAPI[1071:33607] ------2,<NSThread: 0x60000006b900>{number = 1, name = main}
//    2016-12-21 09:29:47.576 GCDBasicAPI[1071:33607] ------3,<NSThread: 0x60000006b900>{number = 1, name = main}
//    2016-12-21 09:29:47.576 GCDBasicAPI[1071:33607] synchConcurrent------end

}


/*
 *  异步并发   --->       不阻塞当前线程，可以开多条线程，并发执行，顺序不一定
 */
- (void)asynchConcurrent
{
    // 全局并发队列
//    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    // 自定义并发队列
    dispatch_queue_t queue1 = dispatch_queue_create("COM.MKJ.COM", DISPATCH_QUEUE_CONCURRENT);

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

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

    dispatch_async(queue1, ^{
        NSLog(@"------3,%@",[NSThread currentThread]);
    });
    NSLog(@"asynchConcurrent------end");
//    2016-12-21 09:28:23.895 GCDBasicAPI[1050:32223] asynchConcurrent------end
//    2016-12-21 09:28:23.895 GCDBasicAPI[1050:32292] ------1,<NSThread: 0x60800026e180>{number = 3, name = (null)}
//    2016-12-21 09:28:23.895 GCDBasicAPI[1050:32293] ------3,<NSThread: 0x60800026fbc0>{number = 5, name = (null)}
//    2016-12-21 09:28:23.895 GCDBasicAPI[1050:32295] ------2,<NSThread: 0x60000026e0c0>{number = 4, name = (null)}

}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
简单概括如下：
项目 同步（sync） 异步（async）
串行 当前线程，顺序执行 另一个线程，顺序执行
并发 当前线程，顺序执行 另一个线程，同时执行

可以看出同步和异步就是开线程的能力，同步执行必然一个个顺序执行在当前线程，而异步执行可以根据队列不同来确定顺序还是同步并发执行

2.最基本的线程间通讯方式

// 不阻塞当前线程，后台拉取图片资源
    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        NSURL *url = [NSURL URLWithString:@"https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9GcRCfHVwGXGvrpCBplQieSKsLgfBULL8ZZXSzosPFdoZsvjDlqnOrKK_w58"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        UIImage *image = [UIImage imageWithData:data];
        NSLog(@"获取资源%@",[NSThread currentThread]);
        // 下载完之后回到主线程
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
            NSLog(@"加载资源%@",[NSThread currentThread]);
        });
    });

    //    2016-12-21 09:43:51.675 GCDBasicAPI[1237:45972] 获取资源<NSThread: 0x6000002742c0>{number = 3, name = (null)}
    //    2016-12-21 09:43:51.676 GCDBasicAPI[1237:45929] 加载资源<NSThread: 0x60000007b680>{number = 1, name = main}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

3.其他Barrier，apply，after，Group等常用API

  • dispatch_barrier_async
/*
 *  barrier函数可以阻塞任务，执行到他这里，要等之前的任务执行完才能执行之后的任务
 */
- (void)barrier
{
    dispatch_queue_t queue = dispatch_queue_create("com.mkj.hehe", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"--------1,%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i < 10; i ++)
        {
           NSLog(@"--------2%ld,%@",i,[NSThread currentThread]);
        }

    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"--------3,%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"--------4,%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"--------5,%@",[NSThread currentThread]);
    });
//    2016-12-21 09:58:09.231 GCDBasicAPI[1392:57437] --------1,<NSThread: 0x60000007f400>{number = 5, name = (null)}
//    2016-12-21 09:58:09.231 GCDBasicAPI[1392:57807] --------20,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.232 GCDBasicAPI[1392:57807] --------21,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.233 GCDBasicAPI[1392:57807] --------22,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.233 GCDBasicAPI[1392:57807] --------23,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.233 GCDBasicAPI[1392:57807] --------24,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.233 GCDBasicAPI[1392:57807] --------25,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.233 GCDBasicAPI[1392:57807] --------26,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.234 GCDBasicAPI[1392:57807] --------27,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.234 GCDBasicAPI[1392:57807] --------28,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.234 GCDBasicAPI[1392:57807] --------29,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.234 GCDBasicAPI[1392:57807] --------3,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.235 GCDBasicAPI[1392:57807] --------4,<NSThread: 0x60000007e780>{number = 7, name = (null)}
//    2016-12-21 09:58:09.235 GCDBasicAPI[1392:57437] --------5,<NSThread: 0x60000007f400>{number = 5, name = (null)}
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • dispatch_apply
/*
 *  apply 无序快速遍历，可以用于文件移动等需求
 */
- (void)apply
{
    dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index) {
        NSLog(@"%ld,%@",index,[NSThread currentThread]);
    });
//    2016-12-21 10:04:01.487 GCDBasicAPI[1485:63041] 0,<NSThread: 0x600000069940>{number = 1, name = main}
//    2016-12-21 10:04:01.487 GCDBasicAPI[1485:63172] 2,<NSThread: 0x60800007a940>{number = 7, name = (null)}
//    2016-12-21 10:04:01.487 GCDBasicAPI[1485:63845] 1,<NSThread: 0x60800007a8c0>{number = 6, name = (null)}
//    2016-12-21 10:04:01.487 GCDBasicAPI[1485:63873] 3,<NSThread: 0x60800007ab00>{number = 8, name = (null)}
//    2016-12-21 10:04:01.487 GCDBasicAPI[1485:63041] 4,<NSThread: 0x600000069940>{number = 1, name = main}
//    2016-12-21 10:04:01.488 GCDBasicAPI[1485:63172] 5,<NSThread: 0x60800007a940>{number = 7, name = (null)}
//    2016-12-21 10:04:01.488 GCDBasicAPI[1485:63845] 6,<NSThread: 0x60800007a8c0>{number = 6, name = (null)}
//    2016-12-21 10:04:01.488 GCDBasicAPI[1485:63873] 7,<NSThread: 0x60800007ab00>{number = 8, name = (null)}
//    2016-12-21 10:04:01.488 GCDBasicAPI[1485:63041] 8,<NSThread: 0x600000069940>{number = 1, name = main}
//    2016-12-21 10:04:01.488 GCDBasicAPI[1485:63172] 9,<NSThread: 0x60800007a940>{number = 7, name = (null)}
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • dispatch_after
/*
 *  延时执行
 */
 - (void)delay
{
    // 方法1
    NSLog(@"开始了");
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0*NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"我才开始");
    });
    // 方法2
    [NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(run) userInfo:nil repeats:NO];
}

- (void)run
{
    NSLog(@"run");
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • dispatch_group_async
/*
 *  线程组  实现多个请求完成之后同时刷新UI的问题
 *  把多个任务加入到队列里面，最后都完成之后会调用Notify的方法进行通知，最终刷新UI
 */

- (void)group
{
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.mkj.hh", DISPATCH_QUEUE_CONCURRENT);
    // 线程组
    dispatch_group_t group = dispatch_group_create();
    // 任务1加入组
    dispatch_group_async(group, queue, ^{

        NSURL *url = [NSURL URLWithString:@"https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9GcQxex7CvJ0pArQ8NHwXMaZ8fSt3ALAZBlljTQVlDsh6AIegeMjWWMoSVtej"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        self.image1 = [UIImage imageWithData:data];
    });

    // 任务2加入组
    dispatch_group_async(group, queue, ^{
        // 这里可以一样是耗时的网络请求，暂时处理成本地的
        self.image2 = [UIImage imageNamed:@"Play"];
    });
    // 任务完成之后统一通知
    dispatch_group_notify(group, queue, ^{

        // 这里的queue如果是mainQueue的话就可以直接回到主线程操作需要的UI
        // 现在还是在并发队列里面  进行图片合成  还是放在子线程
        UIGraphicsBeginImageContext(CGSizeMake([UIScreen mainScreen].bounds.size.width, [UIScreen mainScreen].bounds.size.width));
        [self.image1 drawInRect:CGRectMake(0, 0, [UIScreen mainScreen].bounds.size.width, [UIScreen mainScreen].bounds.size.width)];
        [self.image2 drawInRect:CGRectMake([UIScreen mainScreen].bounds.size.width/2, [UIScreen mainScreen].bounds.size.width/2, 30, 40)];
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndImageContext();
        // 回到主线程刷新UI
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
        });

    });
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

这里写图片描述 

4.两种方式实现单例

  • 自己加锁实现
static id obj;

+ (instancetype)shareInstance
{
    @synchronized (self) {
        if (!obj) {
            obj = [[self alloc] init];
        }
    }
    return obj;
}


+ (instancetype)allocWithZone:(struct _NSZone *)zone
{
    @synchronized (self) {
        if (!obj) {
            obj = [super allocWithZone:zone];
        }
    }
    return obj;
}

- (id)copyWithZone:(NSZone *)zone
{
    return obj;
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • GCD实现（直接抽成宏）
#define MKJSingletonH + (instancetype)shareManager;
#define MKJSinletonM \
static id obj; \
 \
+ (instancetype)shareManager \
{ \
    static dispatch_once_t onceToken; \
    dispatch_once(&onceToken, ^{ \
        obj = [[self alloc] init]; \
    }); \
    return obj; \
} \
 \
+ (instancetype)allocWithZone:(struct _NSZone *)zone \
{ \
    static dispatch_once_t onceToken; \
    dispatch_once(&onceToken, ^{ \
        obj = [super allocWithZone:zone]; \
    }); \
    return obj; \
} \
 \
- (id)copyWithZone:(NSZone *)zone \
{ \
    return obj; \
}
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

抽成宏之后可以直接进行调用就OK

@interface ManagerHelper : NSObject
MKJSingletonH
@end

@implementation ManagerHelper
MKJSinletonM
@end
   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

   
   
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

注：这里为什么需要用Static进行修饰，static保证只有本文件才能访问，这样就能形成单例，但是如果不用static修饰，外部也一样能访问，这个时候外部如果置为nil之后，这个对象就不存在了，再也不会创建了，dispatch_once只会执行一次，这样肯定不对的



非常简单的介绍，这里有个Demo，需要的朋友可以下载看看基础用法先，文章头部有介绍GCD死锁解锁的案例文章，需要的也可以看看 
本文Demo传送门

00烽火连城00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
gcd方法代码测试
12-14
gcd的基础方法使用，线程和队列的使用 gcd的基础方法使用，线程和队列的使用
GCD 源码分析.pdf
09-06
GCD 源码分析.pdf
iOS多线程编程之Grand Central Dispatch(GCD)介绍和使用
移动开发记录
09-25 193
介绍： Grand Central Dispatch 简称（GCD）是苹果公司开发的技术，以优化的应用程序支持多核心处理器和其他的对称多处理系统的系统。这建立在任务并行执行的线程池模式的基础上的。它首次发布在Mac OS X 10.6 ，iOS 4及以上也可用。 设计： GCD的工作原理是：让程序平行排队的特定任务，根据可用的处理资源，安排他们在任何可用的处理器核心上执行任务。 一个任务可以是一个...
gcd
shen253135371的博客
07-16 2735
gcd gcd(a,b)=gcd(b,a mod b) 边界条件:gcd(a,0)=a gcd(a,b) * lcm(a,b)=a*b 于是求lcm: a/gcd(a,b)*b; 先除保证中间结果不会溢出 //递归写法 int gcd(int a,int b) { return b==0?a:gcd(b,a%b); } //求a%b余数 int gcd(int a, int b) { i...
gcd算法
m0_74821245的博客
11-10 1963
欧几里德算法 欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。
了解GCD
qq_40319342的博客
04-06 6398
目录 一、GCD简介 二、GCD好处 三、GCD任务和队列 1、任务 同步执行（sync）： 异步执行（async）： 2、队列 串行队列（Serial Dispatch Queue）： 并发队列（Concurrent Dispatch Queue）： 四、GCD的使用步骤 1、队列的创建方法/获取方法 2、 任务的创建方法 五、GCD的基本使用 1、同步执行 + 并发队列 2、异步执行 + 并发队列 3、同步执行 + 串行队列 4、异步执行 + 串行队列 5、主队列
GCD简析
weixin_43661305的博客
03-16 1290
GCD简单分析
GCD 详细讲解
学到老
04-08 9538
1. GCD 简介什么是 GCD 呢？我们先来看看百度百科的解释简单了解下概念。Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。为什么要用 GCD 呢...
深度理解GCD
GXYZY的博客
11-24 613
深度理解欧几里得算法
python实现GCD算法
poplar-master的博客
10-17 8924
GCD算法 采用Python实现四种最大公约数（greatest common divisor）算法，并比较评估性能。 算法原理： 1、辗转相除法： 已知a,b,c为正整数，若a除以b余c，则GCD（a,b）=GCD (b,c)。 2、更相减损术： 任意给定两个正整数，若是偶数，则用2约简。 以较大的数减较小的数，接着把所得的差与较小的数比较，并以大数减小数。 继续这个操作，直到所得的减数和差相等为止。 3、除穷举法： 将小数依次除N（N为从1开始的自然数，结果不为整数则跳过），对得到的数判断其是否可被大数
GCD详解
柏灿的博客
02-23 7802
虽然GCD使用很广，而且在面试时也经常问与GCD相关的问题，但是我相信深入理解关于GCD知识的人不多，大部分是人云亦云，只是使用过GCD完成一些很简单的功能。当然，使用GCD完成一些简单的功能，通常已经能够满足我们的需求了。不过，笔者比较喜欢刨根问底，因此在这里记录下学习的过程。 GCD是Grand Central Dispatch的简称，它是基于C语言的。使用GCD，我们不需要编写线程代码，其
深入理解GCD（一）
03-01
虽然GCD已经出现过一段时间了，但不是每个人都明了其主要内容。这是可以理解的；并发一直很棘手，而GCD是基于C的API，它们就像一组尖锐的棱角戳进Objective-C的平滑世界。我们将分两个部分的教程来深入学习GCD。在这...
计算GCD的简单java程序
07-12
创建最常用的除数计算器；。。。GCD计算器允许您快速查找一组数字的最大公约数；。。。当两个数的最大公约数为1时，这两个数称为互质或相对素数。
GCD.rar_gcd
09-24
最大公约数的计算,各个源描述的编译顺序:gcd.vhd,gcd_stim.vhd
node-v5.11.0-x86.msi
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
41532698775097Facebook Lite_405.0.0.8.113_apkcombo.com.armeabi-v7a.apk
05-07
41532698775097Facebook Lite_405.0.0.8.113_apkcombo.com.armeabi-v7a.apk
2024-2030中国RDF制粒机市场现状研究分析与发展前景预测报告.docx
05-07
2024-2030中国RDF制粒机市场现状研究分析与发展前景预测报告
财务困境-RLPM模型.xlsx
最新发布
05-07
详细介绍及样例数据：https://blog.csdn.net/li514006030/article/details/138549562
verilog gcd
05-18
以下是一个基于Verilog的GCD（最大公约数）模块的示例代码： ```verilog module gcd ( input [31:0] a, input [31:0] b, output reg [31:0] result ); always @(*) begin if (a == 0) begin result ; end ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值