ivylee_mr
ivylee_mr

iOS 多线程 GCD（一）

前言

本文主要接扫GCD的基本使用方法，比如创建并发异步任务、比如创建线程组等内容。

1、GCD的简介

此处省略1万字......

代码的下载地址demo;

2、 GCD 的基本使用

首先我们简单的举个例子，模拟下网络请求的回掉，代码如下。

typedef void(^comletionHandler)(NSString *status);

/**
 模拟网络请求的回掉
 
 @param comletionHandler 模拟网络请求回掉
 */
- (void)netWorkingComletionHandler:(comletionHandler)comletionHandler{
    // 异步子线程 网络请求耗时操作
        NSInteger sleepTimeInterval = [self getRandomNumber:1 to:5];
        NSString *randomNumber = [NSString stringWithFormat:@"当前线程是：%@ 随机等待：%ld秒",[NSThread currentThread],sleepTimeInterval];
        [NSThread sleepForTimeInterval:sleepTimeInterval];
        // 异步主线程 网络请求回掉请求内容
        dispatch_async(dispatch_get_main_queue(), ^{
            
            if (comletionHandler) {
                comletionHandler(randomNumber);
            }
        });
    });
}

我们在使用GCD执行一个线程任务的时候，其实只有两步：

  • 创建一个队列（串行队列或并发队列）
  • 将任务追加到任务的等待队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）

2.1、创建一个队列（串行队列或并发队列）

2.1.1 dispatch_queue_create创建
// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);

$dispatch_queue_create 创建方法 dispatch_queue_create(const char *_Nullable label,dispatch_queue_attr_t _Nullable attr);

  • 参数 label 是一个C语言的字符串，标识这给队列
  • 参数 attr 识别这个参数是串行队列还是并发队列，只有 DISPATCH_QUEUE_SERIAL（串行）或 DISPATCH_QUEUE_CONCURRENT（并行） 两个选择 。
2.1.2 dispatch_get_main_queue()获取主队列
// 主队列的获取方法
dispatch_queue_t queue = dispatch_get_main_queue();

这个是一个串行主队列，也就是我们常说的主线程。

2.1.3 dispatch_get_global_queue()获取全局并发队列
// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

这个是一个串行全局队列，也就是我们常说的子线程。
创建方法 dispatch_get_global_queue(long identifier, unsigned long flags);

  • 参数 identifier 表示队列的优先级，具体的值如下，意义与字面意思一致。
#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
  • 参数 flags 暂时没有任何意义。

2.2、创建任务

GCD 提供了同步执行任务的创建方法和异步执行任务创建方法。

// 同步执行任务创建方法
dispatch_sync(queue, ^{
    // 这里放同步执行任务代码
});

// 异步执行任务创建方法
dispatch_async(queue, ^{
    // 这里放异步执行任务代码
});

2.3、线程队列组合

虽然使用 GCD 只需两步，但是既然我们有两种队列（串行队列/并发队列），两种任务执行方式（同步执行/异步执行），那么我们就有了四种不同的组合方式。这四种不同的组合方式是：

组合 同步(sync) 异步 (async)
并行(concurrent) 没有开启新线程，当前线程中，串行执行任务 如线程充裕会开启新的1个线程，若线程不充裕等待线程空闲后，并行执行任务
串行(serial) 没有开启新线程，当前线程中，串行执行任务 如线程充裕会开启新的1个线程，若线程不充裕等待线程空闲后，串行执行任务
主线程 主线程调用：死锁卡住不执行 主线程中，串行执行任务

3、GCD的基本使用

如下是模拟网络请求回掉的代码

#pragma mark -
#pragma mark -  模拟网络请求回掉
/**
 模拟网络请求的回掉
 
 @param comletionHandler 模拟网络请求回掉
 */
- (void)netWorkingComletionHandler:(comletionHandler)comletionHandler{
    // 异步子线程 网络请求耗时操作
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSInteger sleepTimeInterval = [self getRandomNumber:1 to:5];
        NSString *randomNumber = [NSString stringWithFormat:@"当前线程是：%@ 随机等待：%ld秒",[NSThread currentThread],sleepTimeInterval];
        [NSThread sleepForTimeInterval:sleepTimeInterval];
        // 异步主线程 网络请求回掉请求内容
        dispatch_async(dispatch_get_main_queue(), ^{
            if (comletionHandler) {
                comletionHandler(randomNumber);
            }
        });
    });
}

/**
 获取随机数
 
 @param from 随机数最小值
 @param to 随机数最大值
 @return 最小值与最小值之间的随机数
 */
- (NSInteger)getRandomNumber:(NSInteger)from to:(NSInteger)to {
    return (NSInteger)(from + (arc4random() % (to - from + 1)));
}

3.1、同步执行Sync + 并发队列Concurrent

#pragma mark -
#pragma mark -  同步执行sync + 并发队列CONCURRENT
- (void)syncConcurrentTask{
    
    NSLog(@"当前线程是：%@ syncConcurrentTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_queue_t syncQueue = dispatch_queue_create("syncQueuex", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(syncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
        
    });
    
    dispatch_sync(syncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    
    dispatch_sync(syncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    NSLog(@"当前线程是：%@ syncConcurrentTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果如下

同步执行sync + 并发队列CONCURRENT

2019-04-02 14:13:02.295615+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} syncConcurrentTask---开始
2019-04-02 14:13:02.295832+0800 GCDDemo[1687:198762] 第一并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 14:13:02.296023+0800 GCDDemo[1687:198762] 第一并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 14:13:02.296226+0800 GCDDemo[1687:198762] 第二并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 14:13:02.296404+0800 GCDDemo[1687:198762] 第二并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 14:13:02.296611+0800 GCDDemo[1687:198762] 第三并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 14:13:02.296814+0800 GCDDemo[1687:198762] 第三并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 14:13:02.297006+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} syncConcurrentTask---结束
2019-04-02 14:13:03.299666+0800 GCDDemo[1687:198762] 第三并发 -1- 发回掉结束 当前线程是：{number = 18, name = (null)} 随机等待：1秒
2019-04-02 14:13:04.300250+0800 GCDDemo[1687:198762] 第一并发 -0- 发回掉结束 当前线程是：{number = 9, name = (null)} 随机等待：2秒
2019-04-02 14:13:05.301669+0800 GCDDemo[1687:198762] 第二并发 -0- 发回掉结束 当前线程是：{number = 15, name = (null)} 随机等待：3秒
2019-04-02 14:13:06.301919+0800 GCDDemo[1687:198762] 第二并发 -1- 发回掉结束 当前线程是：{number = 16, name = (null)} 随机等待：4秒
2019-04-02 14:13:07.299635+0800 GCDDemo[1687:198762] 第三并发 -0- 发回掉结束 当前线程是：{number = 17, name = (null)} 随机等待：5秒
2019-04-02 14:13:07.299891+0800 GCDDemo[1687:198762] 第一并发 -1- 发回掉结束 当前线程是：{number = 14, name = (null)} 随机等待：5秒
  • 主线程开启整个任务，同步执行的并发任务均在主线程中添加开启。
  • 所有的同步任务均在 任务 开始 和 结束 中执行。
  • 任务在 开始 和 结束 中顺序执行，全部在主线程中顺序等待执行。
  • 并发未开启多个线程，所有同步执行的并发任务均在主线程中。
  • 网络请求回掉均在子线程中执行，耗时操作后回主线程收到回掉。

3.2、异步执行async + 并发队列CONCURRENT

- (void)asyncConcurrentTask{
    
    NSLog(@"当前线程是：%@ asyncConcurrentTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_queue_t asyncQueue = dispatch_queue_create("asyncQueuex", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    NSLog(@"当前线程是：%@ asyncConcurrentTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

异步执行async + 并发队列CONCURRENT

2019-04-02 14:27:36.434638+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} asyncConcurrentTask---开始
2019-04-02 14:27:36.434864+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} asyncConcurrentTask---结束
2019-04-02 14:27:36.434918+0800 GCDDemo[1687:294549] 第一并发 -0- 当前线程是：{number = 16, name = (null)}
2019-04-02 14:27:36.435030+0800 GCDDemo[1687:309754] 第二并发 -0- 当前线程是：{number = 19, name = (null)}
2019-04-02 14:27:36.435085+0800 GCDDemo[1687:309755] 第三并发 -0- 当前线程是：{number = 20, name = (null)}
2019-04-02 14:27:36.435169+0800 GCDDemo[1687:294549] 第一并发 -1- 当前线程是：{number = 16, name = (null)}
2019-04-02 14:27:36.435301+0800 GCDDemo[1687:309755] 第三并发 -1- 当前线程是：{number = 20, name = (null)}
2019-04-02 14:27:36.435311+0800 GCDDemo[1687:309754] 第二并发 -1- 当前线程是：{number = 19, name = (null)}
2019-04-02 14:27:37.436217+0800 GCDDemo[1687:198762] 第二并发 -0- 发回掉结束 当前线程是：{number = 22, name = (null)} 随机等待：1秒
2019-04-02 14:27:38.436826+0800 GCDDemo[1687:198762] 第一并发 -0- 发回掉结束 当前线程是：{number = 21, name = (null)} 随机等待：2秒
2019-04-02 14:27:39.436183+0800 GCDDemo[1687:198762] 第三并发 -0- 发回掉结束 当前线程是：{number = 23, name = (null)} 随机等待：3秒
2019-04-02 14:27:41.440393+0800 GCDDemo[1687:198762] 第三并发 -1- 发回掉结束 当前线程是：{number = 20, name = (null)} 随机等待：5秒
2019-04-02 14:27:41.440653+0800 GCDDemo[1687:198762] 第二并发 -1- 发回掉结束 当前线程是：{number = 19, name = (null)} 随机等待：5秒
2019-04-02 14:27:41.440829+0800 GCDDemo[1687:198762] 第一并发 -1- 发回掉结束 当前线程是：{number = 16, name = (null)} 随机等待：5秒
  • 主线程异步执行的并发任务由主线程开启以后，全部在子线程创建执行。
  • 所有的同步任务均不在 开始 和 结束 中执行
  • 任务非顺序执行， 开始 和 结束 以后才执行。
  • 并发开启了多个子线程。
  • 网络请求回掉均在子线程中执行，耗时操作后回主线程收到回掉。

3.3、同步执行sync + 串行队列Serial

- (void)syncSerialTask{
    
    NSLog(@"当前线程是：%@ syncSerialTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_queue_t syncQueue = dispatch_queue_create("syncQueuex", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(syncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_sync(syncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_sync(syncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    NSLog(@"当前线程是：%@ syncSerialTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

同步执行sync + 串行队列Serial

2019-04-02 14:34:40.460881+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} syncSerialTask---开始
2019-04-02 14:34:40.461027+0800 GCDDemo[1687:198762] 第一并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 14:34:40.461159+0800 GCDDemo[1687:198762] 第一并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 14:34:40.461311+0800 GCDDemo[1687:198762] 第二并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 14:34:40.461470+0800 GCDDemo[1687:198762] 第二并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 14:34:40.461602+0800 GCDDemo[1687:198762] 第三并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 14:34:40.461734+0800 GCDDemo[1687:198762] 第三并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 14:34:40.461879+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} syncSerialTask---结束
2019-04-02 14:34:41.464691+0800 GCDDemo[1687:198762] 第一并发 -1- 发回掉结束 当前线程是：{number = 24, name = (null)} 随机等待：1秒
2019-04-02 14:34:41.464922+0800 GCDDemo[1687:198762] 第二并发 -0- 发回掉结束 当前线程是：{number = 25, name = (null)} 随机等待：1秒
2019-04-02 14:34:41.465097+0800 GCDDemo[1687:198762] 第三并发 -0- 发回掉结束 当前线程是：{number = 27, name = (null)} 随机等待：1秒
2019-04-02 14:34:41.465276+0800 GCDDemo[1687:198762] 第二并发 -1- 发回掉结束 当前线程是：{number = 26, name = (null)} 随机等待：1秒
2019-04-02 14:34:42.464661+0800 GCDDemo[1687:198762] 第三并发 -1- 发回掉结束 当前线程是：{number = 28, name = (null)} 随机等待：2秒
2019-04-02 14:34:44.464535+0800 GCDDemo[1687:198762] 第一并发 -0- 发回掉结束 当前线程是：{number = 16, name = (null)} 随机等待：4秒
  • 与 同步并发 的结果完全一致
  • 未开启新的线程，主线程同步执行的并发任务全部在主线程开启。
  • 任务顺序执行，全部在主线程中顺序等待执行。
  • 所有的同步任务均在 开始 和 结束 中执行
  • 并发未开启多个线程。
  • 网络请求回掉均在子线程中执行，耗时操作后回主线程收到回掉。

3.4、同步执行sync + 串行队列Serial


#pragma mark -
#pragma mark -  异步执行async + 串行队列Serial
- (void)asyncSerialTask{
    
    NSLog(@"当前线程是：%@ asyncSerialTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_queue_t asyncQueue = dispatch_queue_create("asyncQueuex", DISPATCH_QUEUE_SERIAL);
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
            
        };
    });
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    NSLog(@"当前线程是：%@ asyncSerialTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

异步执行async + 串行队列Serial

2019-04-02 14:42:08.988744+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} asyncSerialTask---开始
2019-04-02 14:42:08.988989+0800 GCDDemo[1687:198762] 当前线程是：{number = 1, name = main} asyncSerialTask---结束
2019-04-02 14:42:08.989040+0800 GCDDemo[1687:317379] 第一并发 -0- 当前线程是：{number = 25, name = (null)}
2019-04-02 14:42:08.989260+0800 GCDDemo[1687:317379] 第一并发 -1- 当前线程是：{number = 25, name = (null)}
2019-04-02 14:42:08.989539+0800 GCDDemo[1687:317379] 第二并发 -0- 当前线程是：{number = 25, name = (null)}
2019-04-02 14:42:08.989784+0800 GCDDemo[1687:317379] 第二并发 -1- 当前线程是：{number = 25, name = (null)}
2019-04-02 14:42:08.990045+0800 GCDDemo[1687:317379] 第三并发 -0- 当前线程是：{number = 25, name = (null)}
2019-04-02 14:42:08.990256+0800 GCDDemo[1687:317379] 第三并发 -1- 当前线程是：{number = 25, name = (null)}
2019-04-02 14:42:10.989722+0800 GCDDemo[1687:198762] 第一并发 -0- 发回掉结束 当前线程是：{number = 29, name = (null)} 随机等待：2秒
2019-04-02 14:42:10.990055+0800 GCDDemo[1687:198762] 第一并发 -1- 发回掉结束 当前线程是：{number = 30, name = (null)} 随机等待：2秒
2019-04-02 14:42:10.990432+0800 GCDDemo[1687:198762] 第三并发 -0- 发回掉结束 当前线程是：{number = 33, name = (null)} 随机等待：2秒
2019-04-02 14:42:10.990673+0800 GCDDemo[1687:198762] 第三并发 -1- 发回掉结束 当前线程是：{number = 34, name = (null)} 随机等待：2秒
2019-04-02 14:42:11.991086+0800 GCDDemo[1687:198762] 第二并发 -0- 发回掉结束 当前线程是：{number = 31, name = (null)} 随机等待：3秒
2019-04-02 14:42:12.994463+0800 GCDDemo[1687:198762] 第二并发 -1- 发回掉结束 当前线程是：{number = 32, name = (null)} 随机等待：4秒
  • 开启了一个子线程，主线程异步执行的并发任务全部在子线程开启。
  • 任务顺序执行，全部在主线程中顺序等待执行。
  • 所有的异步任务均不在 开始 和 结束 中执行。
  • 开启了一个子线程，所有异步创建的任务均在这个子线程中顺序执行。
  • 网络请求回掉均在子线程中执行，耗时操作后回主线程收到回掉。

3.5、异步执行async + 主线程


#pragma mark -
#pragma mark -  异步执行async + 主线程
- (void)asyncMainThreadTask{
    
    NSLog(@"当前线程是：%@ asyncMainThreadTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    NSLog(@"当前线程是：%@ asyncMainThreadTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

异步执行sync + 主线程

2019-04-02 15:35:17.420403+0800 GCDDemo[2068:378102] 当前线程是：{number = 1, name = main} asyncMainThreadTask---开始
2019-04-02 15:35:17.420681+0800 GCDDemo[2068:378102] 当前线程是：{number = 1, name = main} asyncMainThreadTask---结束
2019-04-02 15:35:17.421753+0800 GCDDemo[2068:378102] 第一并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 15:35:17.421900+0800 GCDDemo[2068:378102] 第一并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 15:35:17.422021+0800 GCDDemo[2068:378102] 第二并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 15:35:17.422173+0800 GCDDemo[2068:378102] 第二并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 15:35:17.422309+0800 GCDDemo[2068:378102] 第三并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 15:35:17.422470+0800 GCDDemo[2068:378102] 第三并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 15:35:18.425564+0800 GCDDemo[2068:378102] 第二并发 -0- 发回掉结束 当前线程是：{number = 5, name = (null)} 随机等待：1秒
2019-04-02 15:35:19.426342+0800 GCDDemo[2068:378102] 第三并发 -0- 发回掉结束 当前线程是：{number = 7, name = (null)} 随机等待：2秒
2019-04-02 15:35:19.426601+0800 GCDDemo[2068:378102] 第三并发 -1- 发回掉结束 当前线程是：{number = 8, name = (null)} 随机等待：2秒
2019-04-02 15:35:19.426794+0800 GCDDemo[2068:378102] 第一并发 -0- 发回掉结束 当前线程是：{number = 3, name = (null)} 随机等待：2秒
2019-04-02 15:35:21.425182+0800 GCDDemo[2068:378102] 第一并发 -1- 发回掉结束 当前线程是：{number = 4, name = (null)} 随机等待：4秒
2019-04-02 15:35:22.425825+0800 GCDDemo[2068:378102] 第二并发 -1- 发回掉结束 当前线程是：{number = 6, name = (null)} 随机等待：5秒
  • 同 串行并发

3.6、同步执行sync + 主线程


#pragma mark -
#pragma mark -  同步执行sync + 主线程
- (void)syncMainThreadTask{
    NSLog(@"当前线程是：%@ syncMainThreadTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_sync(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
            
        };
    });
    
    dispatch_sync(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_sync(mainQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    NSLog(@"当前线程是：%@ syncMainThreadTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

同步执行sync + 主线程

2019-04-02 15:38:59.040983+0800 GCDDemo[2068:378102] 当前线程是：{number = 1, name = main} syncMainThreadTask---开始
(lldb)
  • 会崩溃。死锁
  • 崩溃原因
Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)
  • 死锁分析 首先执行任务1，这是肯定没问题的，只是接下来，程序遇到了同步线程，那么它会进入等待，等待任务2执行完，然后执行任务3。但这是队列，有任务来，当然会将任务加到队尾，然后遵循FIFO原则执行任务。那么，现在任务2就会被加到最后，任务3排在了任务2前面，问题来了：任务3要等任务2执行完才能执行，任务2由排在任务3后面，意味着任务2要在任务3执行完才能执行，所以他们进入了互相等待的局面。这就是死锁。

4、 GCD 栅栏方法：dispatch_barrier_async

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。

dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。

代码如下

#pragma mark -
#pragma mark - 栅栏方法
- (void)asyncBarrierTask{
    NSLog(@"当前线程是：%@ asyncBarrierTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_queue_t asyncQueue = dispatch_queue_create("asyncQueuex", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
            
        };
    });
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_barrier_async(asyncQueue, ^{
        // 追加任务 barrier
        for (int i = 0; i < 2; i++) {
            NSLog(@"barrier -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"barrier -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_async(asyncQueue, ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第四并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第四并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    NSLog(@"当前线程是：%@ asyncBarrierTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

异步执行sync + 栅栏Barrier

2019-04-02 15:59:36.216231+0800 GCDDemo[2299:421705] 当前线程是：{number = 1, name = main} asyncBarrierTask---开始
2019-04-02 15:59:36.216535+0800 GCDDemo[2299:421705] 当前线程是：{number = 1, name = main} asyncBarrierTask---结束
2019-04-02 15:59:36.216590+0800 GCDDemo[2299:421760] 第一并发 -0- 当前线程是：{number = 3, name = (null)}
2019-04-02 15:59:36.216619+0800 GCDDemo[2299:421762] 第二并发 -0- 当前线程是：{number = 4, name = (null)}
2019-04-02 15:59:36.216841+0800 GCDDemo[2299:421762] 第二并发 -1- 当前线程是：{number = 4, name = (null)}
2019-04-02 15:59:36.216849+0800 GCDDemo[2299:421760] 第一并发 -1- 当前线程是：{number = 3, name = (null)}
2019-04-02 15:59:36.217116+0800 GCDDemo[2299:421765] barrier -0- 当前线程是：{number = 7, name = (null)}
2019-04-02 15:59:36.217297+0800 GCDDemo[2299:421765] barrier -1- 当前线程是：{number = 7, name = (null)}
2019-04-02 15:59:36.217577+0800 GCDDemo[2299:421897] 第三并发 -0- 当前线程是：{number = 9, name = (null)}
2019-04-02 15:59:36.217591+0800 GCDDemo[2299:421898] 第四并发 -0- 当前线程是：{number = 10, name = (null)}
2019-04-02 15:59:36.222329+0800 GCDDemo[2299:421897] 第三并发 -1- 当前线程是：{number = 9, name = (null)}
2019-04-02 15:59:36.222329+0800 GCDDemo[2299:421898] 第四并发 -1- 当前线程是：{number = 10, name = (null)}
2019-04-02 15:59:37.219824+0800 GCDDemo[2299:421705] 第二并发 -0- 发回掉结束 当前线程是：{number = 6, name = (null)} 随机等待：1秒
2019-04-02 15:59:37.223322+0800 GCDDemo[2299:421705] 第四并发 -1- 发回掉结束 当前线程是：{number = 9, name = (null)} 随机等待：1秒
2019-04-02 15:59:38.220144+0800 GCDDemo[2299:421705] barrier -1- 发回掉结束 当前线程是：{number = 7, name = (null)} 随机等待：2秒
2019-04-02 15:59:38.224344+0800 GCDDemo[2299:421705] 第三并发 -0- 发回掉结束 当前线程是：{number = 11, name = (null)} 随机等待：2秒
2019-04-02 15:59:39.217972+0800 GCDDemo[2299:421705] 第一并发 -1- 发回掉结束 当前线程是：{number = 4, name = (null)} 随机等待：3秒
2019-04-02 15:59:39.218202+0800 GCDDemo[2299:421705] 第一并发 -0- 发回掉结束 当前线程是：{number = 5, name = (null)} 随机等待：3秒
2019-04-02 15:59:39.224897+0800 GCDDemo[2299:421705] 第四并发 -0- 发回掉结束 当前线程是：{number = 12, name = (null)} 随机等待：3秒
2019-04-02 15:59:40.220113+0800 GCDDemo[2299:421705] barrier -0- 发回掉结束 当前线程是：{number = 8, name = (null)} 随机等待：4秒
2019-04-02 15:59:41.221252+0800 GCDDemo[2299:421705] 第二并发 -1- 发回掉结束 当前线程是：{number = 3, name = (null)} 随机等待：5秒
2019-04-02 15:59:41.225311+0800 GCDDemo[2299:421705] 第三并发 -1- 发回掉结束 当前线程是：{number = 10, name = (null)} 随机等待：5秒
  • 如果没有 dispatch_barrier_async，应该打印结果会按照异步并发的打印结果来执行
  • 如果有 dispatch_barrier_async，dispatch_barrier_async任务之前的所有并发任务必须全部发起执行后，再发起执行dispatch_barrier_async中的任务，最后发起执行dispatch_barrier_async后的任务。
  • 但是每个模拟网络请求任务的回掉不在dispatch_barrier_async的控制范围，所以，dispatch_barrier_async只是控制了任务的发起，并不关系并发任务的回掉内容。

5、 GCD 延时执行：dispatch_after

我们经常会遇到这样的需求：在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。
需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。

#pragma mark -
#pragma mark - 延时等待
- (void)excuteGCDAfterMehod{
    NSLog(@"当前线程是：%@ excuteAfterMehod---开始",[NSThread currentThread]);  // 打印当前线程
    // 子线程等待3秒
    dispatch_time_t globalQueueTimeAfter = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC));
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_after(globalQueueTimeAfter, globalQueue, ^{
        NSLog(@"当前线程是：%@ excuteAfterMehod---子线程继续",[NSThread currentThread]);  // 打印当前线程
        // 主线程等待1秒
        dispatch_time_t mainQueueTimeAfter = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));
        dispatch_queue_t mainQueue = dispatch_get_main_queue();
        dispatch_after(mainQueueTimeAfter, mainQueue, ^{
            NSLog(@"当前线程是：%@ excuteAfterMehod---主线程继续",[NSThread currentThread]);  // 打印当前线程
        });
    });
}

打印结果

2019-04-02 16:24:05.623341+0800 GCDDemo[2485:452952] 延时执行
2019-04-02 16:24:05.623582+0800 GCDDemo[2485:452952] 当前线程是：{number = 1, name = main} excuteAfterMehod---开始
2019-04-02 16:24:08.624034+0800 GCDDemo[2485:453017] 当前线程是：{number = 3, name = (null)} excuteAfterMehod---子线程继续
2019-04-02 16:24:09.711925+0800 GCDDemo[2485:452952] 当前线程是：{number = 1, name = main} excuteAfterMehod---主线程继续
  • 从打印结果来看，第一个回掉任务 是在子线程中加入，延时等待了3秒
  • 第二个回掉任务是在主线程中加入，延时等待了1秒

6、GCD 队列组：dispatch_group

有时候我们会有这样的应用场景：分别异步执行多个耗时任务，然后当多个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

目前实现上述需求的有三个解决方案dispatch_group_notify 或dispatch_group_wait或dispatch_group_enter+dispatch_group_leave方案。

6.1、方案1：dispatch_group_notify 

#pragma mark -
#pragma mark -  dispatch_group_notify

- (void)asyncGroupNotifyTask{
    
    NSLog(@"当前线程是：%@ asyncGroupNotifyTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_group_t group =  dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    NSLog(@"当前线程是：%@ asyncGroupNotifyTask---继续",[NSThread currentThread]);  // 打印当前线程
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第三并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第三并发 -%d- 发回掉结束 %@",i,status);
            }];
            NSLog(@"当前线程是：%@ asyncGroupNotifyTask---结束",[NSThread currentThread]);  // 打印当前线程
        };
    });
    
}

打印结果

2019-04-02 17:26:46.398977+0800 GCDDemo[2999:527321] GroupNotify
2019-04-02 17:26:46.399196+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupNotifyTask---开始
2019-04-02 17:26:46.399346+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupNotifyTask---继续
2019-04-02 17:26:46.399372+0800 GCDDemo[2999:527374] 第二并发 -0- 当前线程是：{number = 4, name = (null)}
2019-04-02 17:26:46.399386+0800 GCDDemo[2999:527373] 第一并发 -0- 当前线程是：{number = 3, name = (null)}
2019-04-02 17:26:46.399784+0800 GCDDemo[2999:527374] 第二并发 -1- 当前线程是：{number = 4, name = (null)}
2019-04-02 17:26:46.399788+0800 GCDDemo[2999:527373] 第一并发 -1- 当前线程是：{number = 3, name = (null)}
2019-04-02 17:26:46.400116+0800 GCDDemo[2999:527321] 第三并发 -0- 当前线程是：{number = 1, name = main}
2019-04-02 17:26:46.400218+0800 GCDDemo[2999:527321] 第三并发 -1- 当前线程是：{number = 1, name = main}
2019-04-02 17:26:46.400345+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupNotifyTask---结束
2019-04-02 17:26:47.403711+0800 GCDDemo[2999:527321] 第二并发 -0- 发回掉结束 当前线程是：{number = 5, name = (null)} 随机等待：1秒
2019-04-02 17:26:48.405119+0800 GCDDemo[2999:527321] 第二并发 -1- 发回掉结束 当前线程是：{number = 4, name = (null)} 随机等待：2秒
2019-04-02 17:26:49.400737+0800 GCDDemo[2999:527321] 第三并发 -1- 发回掉结束 当前线程是：{number = 8, name = (null)} 随机等待：3秒
2019-04-02 17:26:50.401832+0800 GCDDemo[2999:527321] 第一并发 -1- 发回掉结束 当前线程是：{number = 3, name = (null)} 随机等待：4秒
2019-04-02 17:26:51.402809+0800 GCDDemo[2999:527321] 第一并发 -0- 发回掉结束 当前线程是：{number = 6, name = (null)} 随机等待：5秒
2019-04-02 17:26:51.403048+0800 GCDDemo[2999:527321] 第三并发 -0- 发回掉结束 当前线程是：{number = 7, name = (null)} 随机等待：5秒
  • 从打印几个来看，dispatch_group_notify能保证我们的目标操作一定能在我们的前两个并发的耗时操作之后执行dispatch_group_notify回掉中的任务。
  • 不会阻塞当前线程，因为目标等待任务可以在都是dispatch_group_notify回掉中的执行
  • 无法控制回掉并发任务的回掉。

6.2、方案2：dispatch_group_wait 


#pragma mark -
#pragma mark -  dispatch_group_wait
- (void)asyncGroupWaitTask{
    
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_group_t group =  dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第一并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第一并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        for (int i = 0; i < 2; i++) {
            NSLog(@"第二并发 -%d- 当前线程是：%@",i,[NSThread currentThread]);  // 打印当前线程
            [self netWorkingComletionHandler:^(NSString *status) {
                NSLog(@"第二并发 -%d- 发回掉结束 %@",i,status);
            }];
        };
    });
    
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---继续",[NSThread currentThread]);  // 打印当前线程
    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

2019-04-02 17:27:27.189132+0800 GCDDemo[2999:527321] GroupWait
2019-04-02 17:27:27.189417+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---开始
2019-04-02 17:27:27.189656+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---继续
2019-04-02 17:27:27.189704+0800 GCDDemo[2999:527373] 第一并发 -0- 当前线程是：{number = 3, name = (null)}
2019-04-02 17:27:27.189815+0800 GCDDemo[2999:528259] 第二并发 -0- 当前线程是：{number = 9, name = (null)}
2019-04-02 17:27:27.189969+0800 GCDDemo[2999:527373] 第一并发 -1- 当前线程是：{number = 3, name = (null)}
2019-04-02 17:27:27.190108+0800 GCDDemo[2999:528259] 第二并发 -1- 当前线程是：{number = 9, name = (null)}
2019-04-02 17:27:27.190361+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---结束
2019-04-02 17:27:28.193774+0800 GCDDemo[2999:527321] 第二并发 -0- 发回掉结束 当前线程是：{number = 11, name = (null)} 随机等待：1秒
2019-04-02 17:27:29.193748+0800 GCDDemo[2999:527321] 第二并发 -1- 发回掉结束 当前线程是：{number = 9, name = (null)} 随机等待：2秒
2019-04-02 17:27:29.193998+0800 GCDDemo[2999:527321] 第一并发 -0- 发回掉结束 当前线程是：{number = 10, name = (null)} 随机等待：2秒
2019-04-02 17:27:31.191027+0800 GCDDemo[2999:527321] 第一并发 -1- 发回掉结束 当前线程是：{number = 3, name = (null)} 随机等待：4秒
  • 从打印几个来看，dispatch_group_wait能保证我们的目标操作一定能在我们的前两个并发的耗时操作之后执行dispatch_group_wait执行之后执行后的内容。
  • 暂停当前线程（阻塞当前线程），等待指定的group 中的任务执行完成后，才会往下继续执行
  • 无法控制回掉并发任务的回掉。

6.3、方案3：dispatch_group_enter+dispatch_group_leave 


#pragma mark -
#pragma mark -  dispatch_group_enter dispatch_group_leave
- (void)asyncGroupEnterAndLeaveTask{
    
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---开始",[NSThread currentThread]);  // 打印当前线程
    dispatch_group_t group =  dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---第一个网络请求",[NSThread currentThread]);  // 打印当前线程
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"第一并发  当前线程是：%@",[NSThread currentThread]);  // 打印当前线程
        [self netWorkingComletionHandler:^(NSString *status) {
            NSLog(@"第一并发  发回掉结束 %@",status);
            dispatch_group_leave(group);
        }];
    });
  
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---第二个网络请求",[NSThread currentThread]);  // 打印当前线程
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"第二并发  当前线程是：%@",[NSThread currentThread]);  // 打印当前线程
        [self netWorkingComletionHandler:^(NSString *status) {
            NSLog(@"第二并发  发回掉结束 %@",status);
            dispatch_group_leave(group);
        }];
    });
    
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---第三个网络请求",[NSThread currentThread]);  // 打印当前线程
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"第三并发  当前线程是：%@",[NSThread currentThread]);  // 打印当前线程
        [self netWorkingComletionHandler:^(NSString *status) {
            NSLog(@"第三并发  发回掉结束 %@",status);
            dispatch_group_leave(group);
        }];
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"网络回掉任务全部完成  当前线程是：%@",[NSThread currentThread]);  // 打印当前线程
    });
    NSLog(@"当前线程是：%@ asyncGroupWaitTask---结束",[NSThread currentThread]);  // 打印当前线程
}

打印结果

2019-04-02 17:29:55.232737+0800 GCDDemo[2999:527321] GroupEnterAndLeave
2019-04-02 17:29:55.233021+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---开始
2019-04-02 17:29:55.233251+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---第一个网络请求
2019-04-02 17:29:55.233462+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---第二个网络请求
2019-04-02 17:29:55.233508+0800 GCDDemo[2999:527373] 第一并发  当前线程是：{number = 3, name = (null)}
2019-04-02 17:29:55.233677+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---第三个网络请求
2019-04-02 17:29:55.233687+0800 GCDDemo[2999:527373] 第二并发  当前线程是：{number = 3, name = (null)}
2019-04-02 17:29:55.233853+0800 GCDDemo[2999:527321] 当前线程是：{number = 1, name = main} asyncGroupWaitTask---结束
2019-04-02 17:29:55.233865+0800 GCDDemo[2999:527373] 第三并发  当前线程是：{number = 3, name = (null)}
2019-04-02 17:29:56.238667+0800 GCDDemo[2999:527321] 第一并发  发回掉结束 当前线程是：{number = 12, name = (null)} 随机等待：1秒
2019-04-02 17:29:56.238904+0800 GCDDemo[2999:527321] 第二并发  发回掉结束 当前线程是：{number = 13, name = (null)} 随机等待：1秒
2019-04-02 17:30:00.238412+0800 GCDDemo[2999:527321] 第三并发  发回掉结束 当前线程是：{number = 3, name = (null)} 随机等待：5秒
2019-04-02 17:30:00.238717+0800 GCDDemo[2999:527321] 网络回掉任务全部完成  当前线程是：{number = 1, name = main}
  • 完美切合目前的网络请求
  • 保证在每个网络请求的延时操作得到回掉之后在执行最后的操作。
  • dispatch_group_enter+dispatch_group_leave 必须是成对出现，比如必须在创建并发任务前，必须先执行 dispatch_group_enter(group);方法，再创建并发任务，在接收到任务的block回掉方法中再执行 dispatch_group_leave(group);。

代码的下载地址demo;

你可能感兴趣的:(iOS 多线程 GCD（一）)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • Java序列化进阶篇 g21121 java序列化
            1.transient         类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。
  • escape()、encodeURI()、encodeURIComponent()区别详解 aigo JavaScriptWeb
    原文：http://blog.sina.com.cn/s/blog_4586764e0101khi0.html   JavaScript中有三个可以对字符串编码的函数，分别是： escape,encodeURI,encodeURIComponent，相应3个解码函数：,decodeURI,decodeURIComponent 。 下面简单介绍一下它们的区别 1 escape()函
  • ArcgisEngine实现对地图的放大、缩小和平移 Cb123456 添加矢量数据对地图的放大、缩小和平移Engine
    ArcgisEngine实现对地图的放大、缩小和平移:  个人觉得是平移，不过网上的都是漫游，通俗的说就是把一个地图对象从一边拉到另一边而已。就看人说话吧.  具体实现: 一、引入命名空间    using ESRI.ArcGIS.Geometry;    using ESRI.ArcGIS.Controls; 二、代码实现.
  • Java集合框架概述 天子之骄 Java集合框架概述
       集合框架 集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。 从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。   简单介绍：   Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
  • 旗正4.0页面跳转传值问题 何必如此 javajsp
    跳转和成功提示 a)        成功字段非空forward 成功字段非空forward，不会弹出成功字段，为jsp转发，页面能超链接传值,传输变量时需要拼接。接拼接方式list.jsp?test="+strweightUnit+"或list.jsp?test="+weightUnit+&qu
  • 全网唯一:移动互联网服务器端开发课程 cocos2d-x小菜 web开发移动开发移动端开发移动互联程序员
        移动互联网时代来了！     App市场爆发式增长为Web开发程序员带来新一轮机遇，近两年新增创业者，几乎全部选择了移动互联网项目！传统互联网企业中超过98%的门户网站已经或者正在从单一的网站入口转向PC、手机、Pad、智能电视等多端全平台兼容体系。据统计，AppStore中超过85%的App项目都选择了PHP作为后端程
  • Log4J通用配置|注意问题 笔记 7454103 DAOapachetomcatlog4jWeb
    关于日志的等级 那些去 百度就知道了！ 这几天 要搭个新框架  配置了 日志 记下来 ！做个备忘！ #这里定义能显示到的最低级别,若定义到INFO级别,则看不到DEBUG级别的信息了~! log4j.rootLogger=INFO,allLog # DAO层 log记录到dao.log 控制台 和 总日志文件 log4j.logger.DAO=INFO,dao,C
  • SQLServer TCP/IP 连接失败问题 ---SQL Server Configuration Manager darkranger sqlcwindowsSQL ServerXP
    当你安装完之后,连接数据库的时候可能会发现你的TCP/IP 没有启动.. 发现需要启动客户端协议 : TCP/IP  需要打开 SQL Server Configuration Manager... 却发现无法打开 SQL Server Configuration Manager..?? 解决方法:  C:\WINDOWS\system32目录搜索framedyn.
  • [置顶] 做有中国特色的程序员 aijuans 程序员
    从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有些技术书读得可
  • document.domain 跨域问题 avords document
    document.domain用来得到当前网页的域名。比如在地址栏里输入：javascript:alert(document.domain); //www.315ta.com我们也可以给document.domain属性赋值，不过是有限制的，你只能赋成当前的域名或者基础域名。比如：javascript:alert(document.domain = "315ta.com");
  • 关于管理软件的一些思考 houxinyou 管理
    工作好多看年了,一直在做管理软件,不知道是我最开始做的时候产生了一些惯性的思维,还是现在接触的管理软件水平有所下降.换过好多年公司,越来越感觉现在的管理软件做的越来越乱. 在我看来,管理软件不论是以前的结构化编程,还是现在的面向对象编程,不管是CS模式,还是BS模式.模块的划分是很重要的.当然,模块的划分有很多种方式.我只是以我自己的划分方式来说一下. 做为管理软件,就像现在讲究MVC这
  • NoSQL数据库之Redis数据库管理(String类型和hash类型) bijian1013 redis数据库NoSQL
    一.Redis的数据类型 1.String类型及操作         String是最简单的类型，一个key对应一个value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。         Set方法：设置key对应的值为string类型的value
  • Tomcat 一些技巧 征客丶 javatomcatdos
    以下操作都是在windows 环境下 一、Tomcat 启动时配置 JAVA_HOME 在 tomcat 安装目录，bin 文件夹下的 catalina.bat 或 setclasspath.bat 中添加 set JAVA_HOME=JAVA 安装目录 set JRE_HOME=JAVA 安装目录/jre 即可； 二、查看Tomcat 版本 在 tomcat 安装目
  • 【Spark七十二】Spark的日志配置 bit1129 spark
    在测试Spark Streaming时，大量的日志显示到控制台，影响了Spark Streaming程序代码的输出结果的查看(代码中通过println将输出打印到控制台上)，可以通过修改Spark的日志配置的方式，不让Spark Streaming把它的日志显示在console   在Spark的conf目录下，把log4j.properties.template修改为log4j.p
  • Haskell版冒泡排序 bookjovi 冒泡排序haskell
    面试的时候问的比较多的算法题要么是binary search，要么是冒泡排序，真的不想用写C写冒泡排序了，贴上个Haskell版的，思维简单，代码简单，下次谁要是再要我用C写冒泡排序，直接上个haskell版的，让他自己去理解吧。     sort [] = [] sort [x] = [x] sort (x:x1:xs) | x>x1 = x1:so
  • java 路径 配置文件读取 bro_feng java
    这几天做一个项目，关于路径做如下笔记，有需要供参考。 取工程内的文件，一般都要用相对路径，这个自然不用多说。 在src统计目录建配置文件目录res,在res中放入配置文件。 读取文件使用方式： 1. MyTest.class.getResourceAsStream("/res/xx.properties") 2. properties.load(MyTest.
  • 读《研磨设计模式》-代码笔记-简单工厂模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 个人理解：简单工厂模式就是IOC; * 客户端要用到某一对象，本来是由客户创建的，现在改成由工厂创建，客户直接取就好了 */ interface IProduct {
  • SVN与JIRA的关联 chenyu19891124 SVN
    SVN与JIRA的关联一直都没能装成功，今天凝聚心思花了一天时间整合好了。下面是自己整理的步骤： 一、搭建好SVN环境，尤其是要把SVN的服务注册成系统服务 二、装好JIRA，自己用是jira-4.3.4破解版 三、下载SVN与JIRA的插件并解压，然后拷贝插件包下lib包里的三个jar，放到Atlassian\JIRA 4.3.4\atlassian-jira\WEB-INF\lib下，再
  • JWFDv0.96 最新设计思路 comsci 数据结构算法工作企业应用公告
                       随着工作流技术的发展，工作流产品的应用范围也不断的在扩展，开始进入了像金融行业(我已经看到国有四大商业银行的工作流产品招标公告了)，实时生产控制和其它比较重要的工程领域，而
  • vi 保存复制内容格式粘贴 daizj vi粘贴复制保存原格式不变形
        vi是linux中非常好用的文本编辑工具，功能强大无比，但对于复制带有缩进格式的内容时，粘贴的时候内容错位很严重，不会按照复制时的格式排版，vi能不能在粘贴时，按复制进的格式进行粘贴呢？ 答案是肯定的，vi有一个很强大的命令可以实现此功能 。     在命令模式输入:set paste，则进入paste模式，这样再进行粘贴时
  • shell脚本运行时报错误：/bin/bash^M: bad interpreter 的解决办法 dongwei_6688 shell脚本
    出现原因：windows上写的脚本，直接拷贝到linux系统上运行由于格式不兼容导致 解决办法： 1. 比如文件名为myshell.sh，vim myshell.sh 2. 执行vim中的命令 : set ff?查看文件格式，如果显示fileformat=dos，证明文件格式有问题 3. 执行vim中的命令 :set fileformat=unix 将文件格式改过来就可以了，然后:w
  • 高一上学期难记忆单词 dcj3sjt126com wordenglish
    honest 诚实的；正直的 argue 争论 classical 古典的 hammer 锤子 share  分享；共有 sorrow 悲哀；悲痛 adventure 冒险 error 错误；差错 closet 壁橱；储藏室 pronounce 发音；宣告 repeat 重做；重复 majority 大多数；大半   native 本国的，本地的，本国
  • hibernate查询返回DTO对象，DTO封装了多个pojo对象的属性 frankco POJOhibernate查询DTO
          DTO-数据传输对象；pojo-最纯粹的java对象与数据库中的表一一对应。       简单讲：DTO起到业务数据的传递作用，pojo则与持久层数据库打交道。         有时候我们需要查询返回DTO对象，因为DTO
  • Partition List hcx2013 partition
    Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of th
  • Spring MVC测试框架详解——客户端测试 jinnianshilongnian
    上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一
  • 关于推荐个人观点 liyonghui160com 推荐系统关于推荐个人观点
        回想起来，我也做推荐了3年多了，最近公司做了调整招聘了很多算法工程师，以为需要多么高大上的算法才能搭建起来的，从实践中走过来，我只想说【不是这样的】     第一次接触推荐系统是在四年前入职的时候，那时候，机器学习和大数据都是没有的概念，什么大数据处理开源软件根本不存在，我们用多台计算机web程序记录用户行为，用.net的w
  • 不间断旋转的动画 pangyulei 动画
    CABasicAnimation* rotationAnimation; rotationAnimation = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"]; rotationAnimation.toValue = [NSNumber numberWithFloat: M
  • 自定义annotation sha1064616837 javaenumannotationreflect
    对象有的属性在页面上可编辑，有的属性在页面只可读，以前都是我们在页面上写死的，时间一久有时候会混乱，此处通过自定义annotation在类属性中定义。越来越发现Java的Annotation真心很强大，可以帮我们省去很多代码，让代码看上去简洁。 下面这个例子 主要用到了 1.自定义annotation：@interface，以及几个配合着自定义注解使用的几个注解 2.简单的反射 3.枚举
  • Spring 源码 up2pu spring
    1.Spring源代码 https://github.com/SpringSource/spring-framework/branches/3.2.x 注：兼容svn检出 2.运行脚本 import-into-eclipse.bat 注：需要设置JAVA_HOME为jdk 1.7 build.gradle compileJava { sourceCompatibilit
  • 利用word分词来计算文本相似度 yangshangchuan wordword分词文本相似度余弦相似度简单共有词
    word分词提供了多种文本相似度计算方式： 方式一：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度 实现类：org.apdplat.word.analysis.CosineTextSimilarity 用法如下： String text1 = "我爱购物"; String text2 = "我爱读书"; String text3 =
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他