一个默默无闻的程序猿
一个默默无闻的程序猿

iOS进阶之多线程--GCD

GCD简介

  • GCD全称Grand Central Dispatch，可译为“牛逼的中枢调度系统”，是苹果公司为多核的并行运算提供的解决方案。
  • 开发者借助GCD无需直接操作线程，只需要将准备好的和要执行的任务添加到Dispatch Queue（队列）中，GCD会根据队列类型（串行&并发）和任务的执行类型（同步&异步）来确定要不要开启子线程、和任务的执行顺序。
  • 任务的执行顺序遵循队列的FIFO原则，先进先出、后进后出。
  • 并且要不要开启线程、开几条线程以及线程的生命周期（创建线程、调度热舞、销毁线程）都不需要开发者关心。
  • GCD会自动利用更多的CPU内核（比如：双核、四核、乃至八核），本人也相信苹果的GCD技术也是一大伏笔，虽然目前市场上的苹果手机大都是双核，相信在不久的未来苹果推出更多核芯CPU时GCD会自动适配，届时所有程序员会发现，苹果已经早先一步有了应对多核硬件的技术，并且也不用担心硬件的革新带来项目重构的问题，所以放心地使用GCD！

GCD的几个概念

  1. 任务 同步&异步：
 /**同步执行*/
dispatch_sync(dispatch_queue_t  _Nonnull queue, ^(void)block)
/**异步步执行*/
dispatch_async(dispatch_queue_t  _Nonnull queue, ^(void)block)

这里只要执行的代码，为Block代码块。既然是Block，是不是烦恼的循环引用又来了，block只是一个局部变量，执行完毕之后就释放掉了，不用担心循环引用问题。任务的执行又分同步和异步。
同步：当前任务（代码）没有执行完毕不会执行下一个任务；
异步：当前任务没有执行完毕同样会执行下一个任务（只要有任务，GCD就回到线程池中取线程）（主队列除外）

  1. 队列 串行&并发：
/**
参数：
1.线程名称
2.DISPATCH_QUEUE_SERIAL == NULL 串行
  DISPATCH_QUEUE_CONCURRENT  并发
*/
dispatch_queue_create(const char * _Nullable label, dispatch_queue_attr_t  _Nullable attr)

主要负责调度任务，所有队列都遵循FIFO原则。队列又分为串行队列和并发队列。
串行 队列：一个一个地调度任务。
并发 队列：可以同时调度多个任务，开不开线程是有任务决定的。如果是同步任务：当一个任务没有执行完成，队列也会取任务，只是取出的任务要等待前一个任务执行完毕才开始执行，不会开启线程；如果是异步任务：GCD会开启线程同时执行多个任务。

  1. 小结：
    开不开线程取决于任务，同步不开线程，异步开线程；
    开几条线程由队列决定，串行只开一条，并发（只有异步条件下）可以开启多条。

GCD的相关用法

  1. 串行队列，同步任务
    //串行
    dispatch_queue_t q = dispatch_queue_create("chenjinguo", NULL);
    for (int i = 0; i < 10; i ++) {
        //同步
        dispatch_sync(q, ^{
            NSLog(@"%@   %d",[NSThread currentThread],i);
        });
    }

打印

2018-04-03 11:53:46.883277+0800 GCD演示[1099:402251] {number = 1, name = main}   0
2018-04-03 11:53:46.883576+0800 GCD演示[1099:402251] {number = 1, name = main}   1
2018-04-03 11:53:46.883763+0800 GCD演示[1099:402251] {number = 1, name = main}   2
2018-04-03 11:53:46.883928+0800 GCD演示[1099:402251] {number = 1, name = main}   3
2018-04-03 11:53:46.884098+0800 GCD演示[1099:402251] {number = 1, name = main}   4
2018-04-03 11:53:46.884260+0800 GCD演示[1099:402251] {number = 1, name = main}   5
2018-04-03 11:53:46.884390+0800 GCD演示[1099:402251] {number = 1, name = main}   6
2018-04-03 11:53:46.884529+0800 GCD演示[1099:402251] {number = 1, name = main}   7
2018-04-03 11:53:46.884648+0800 GCD演示[1099:402251] {number = 1, name = main}   8
2018-04-03 11:53:46.884789+0800 GCD演示[1099:402251] {number = 1, name = main}   9
  • 不会开启线程，顺序执行
  1. 串行队列，同步任务
  //串行
  dispatch_queue_t q = dispatch_queue_create("chen_jinguo",DISPATCH_QUEUE_CONCURRENT);
  for(int i = 0; i < 10; i ++){
     NSLog(@"---------%d-------",i);
    //异步
    dispatch_async(q, ^{
        NSLog(@"%@ %d",[NSThread currentThread],i);
    });
  }

打印

2018-04-03 11:58:17.697224+0800 GCD演示[1126:425688] ---------0-------
2018-04-03 11:58:17.697617+0800 GCD演示[1126:426370] {number = 3, name = (null)}   0
2018-04-03 11:58:17.697436+0800 GCD演示[1126:425688] ---------1-------
2018-04-03 11:58:17.698929+0800 GCD演示[1126:425688] ---------2-------
2018-04-03 11:58:17.699189+0800 GCD演示[1126:425688] ---------3-------
2018-04-03 11:58:17.699223+0800 GCD演示[1126:426370] {number = 3, name = (null)}   1
2018-04-03 11:58:17.699405+0800 GCD演示[1126:425688] ---------4-------
2018-04-03 11:58:17.699447+0800 GCD演示[1126:426370] {number = 3, name = (null)}   2
2018-04-03 11:58:17.701129+0800 GCD演示[1126:425688] ---------5-------
2018-04-03 11:58:17.702702+0800 GCD演示[1126:426370] {number = 3, name = (null)}   3
2018-04-03 11:58:17.703452+0800 GCD演示[1126:425688] ---------6-------
2018-04-03 11:58:17.703831+0800 GCD演示[1126:426370] {number = 3, name = (null)}   4
2018-04-03 11:58:17.704094+0800 GCD演示[1126:425688] ---------7-------
2018-04-03 11:58:17.704316+0800 GCD演示[1126:426370] {number = 3, name = (null)}   5
2018-04-03 11:58:17.743690+0800 GCD演示[1126:425688] ---------8-------
2018-04-03 11:58:17.743782+0800 GCD演示[1126:426370] {number = 3, name = (null)}   6
2018-04-03 11:58:17.743979+0800 GCD演示[1126:425688] ---------9-------
2018-04-03 11:58:17.744001+0800 GCD演示[1126:426370] {number = 3, name = (null)}   7
2018-04-03 11:58:17.744380+0800 GCD演示[1126:425688] come here
2018-04-03 11:58:17.744407+0800 GCD演示[1126:426370] {number = 3, name = (null)}   8
2018-04-03 11:58:17.744776+0800 GCD演示[1126:426370] {number = 3, name = (null)}   9
  • 会开启一条线程，顺序执行
  1. 并发队列，异步任务
    //队列 - 并发 DISPATCH_QUEUE_CONCURRENT
    dispatch_queue_t q = dispatch_queue_create("chenjinguo", DISPATCH_QUEUE_CONCURRENT);
    //执行 - 异步
    for (int i = 0; i < 10; i ++) {
        dispatch_async(q, ^{
            NSLog(@"%@   %d",[NSThread currentThread],i);
        });
    }
    NSLog(@"come here");

打印

2018-04-03 13:36:05.457846+0800 GCD演示[1213:499948] come here
2018-04-03 13:36:05.458007+0800 GCD演示[1213:500170] {number = 4, name = (null)}   1
2018-04-03 13:36:05.458008+0800 GCD演示[1213:500169] {number = 3, name = (null)}   0
2018-04-03 13:36:05.458010+0800 GCD演示[1213:500171] {number = 6, name = (null)}   3
2018-04-03 13:36:05.458012+0800 GCD演示[1213:500180] {number = 5, name = (null)}   2
2018-04-03 13:36:05.458301+0800 GCD演示[1213:500170] {number = 4, name = (null)}   5
2018-04-03 13:36:05.458310+0800 GCD演示[1213:500168] {number = 7, name = (null)}   4
2018-04-03 13:36:05.458323+0800 GCD演示[1213:500169] {number = 3, name = (null)}   6
2018-04-03 13:36:05.458345+0800 GCD演示[1213:500171] {number = 6, name = (null)}   7
2018-04-03 13:36:05.458451+0800 GCD演示[1213:500168] {number = 7, name = (null)}   8
2018-04-03 13:36:05.458476+0800 GCD演示[1213:500170] {number = 4, name = (null)}   9
  • 会开启多条线程，非顺序执行
  1. 并发队列，同步任务
    //队列 - 并发 DISPATCH_QUEUE_CONCURRENT
    dispatch_queue_t q = dispatch_queue_create("chenjinguo", DISPATCH_QUEUE_CONCURRENT);
    //执行 - 同步
    for (int i = 0; i < 10; i ++) {
        dispatch_sync(q, ^{
            NSLog(@"%@   %d",[NSThread currentThread],i);
        });
    }
    NSLog(@"come here");

打印

2018-04-03 13:37:58.162147+0800 GCD演示[1228:510822] {number = 1, name = main}   0
2018-04-03 13:37:58.162436+0800 GCD演示[1228:510822] {number = 1, name = main}   1
2018-04-03 13:37:58.163300+0800 GCD演示[1228:510822] {number = 1, name = main}   2
2018-04-03 13:37:58.163621+0800 GCD演示[1228:510822] {number = 1, name = main}   3
2018-04-03 13:37:58.163761+0800 GCD演示[1228:510822] {number = 1, name = main}   4
2018-04-03 13:37:58.163916+0800 GCD演示[1228:510822] {number = 1, name = main}   5
2018-04-03 13:37:58.164035+0800 GCD演示[1228:510822] {number = 1, name = main}   6
2018-04-03 13:37:58.164410+0800 GCD演示[1228:510822] {number = 1, name = main}   7
2018-04-03 13:37:58.164839+0800 GCD演示[1228:510822] {number = 1, name = main}   8
2018-04-03 13:37:58.165329+0800 GCD演示[1228:510822] {number = 1, name = main}   9
2018-04-03 13:37:58.165824+0800 GCD演示[1228:510822] come here
  • 不会开启线程，顺序执行
  1. 同步任务
    在开发中，通常会把耗时任务放在后台执行，有时候，有些任务彼此有“依赖”关系！
    例子：登录、支付、下载
    利用同步任务，能够任务的依赖关系，前一个是同步任务，如果不执行完，队列就不会调度后面的任务
dispatch_queue_t q = dispatch_queue_create("ChenJinguo", DISPATCH_QUEUE_CONCURRENT);
    //1、登录
    dispatch_sync(q, ^{
        NSLog(@"用户登录----- %@",[NSThread currentThread]);
        
    });
    //2、支付
    dispatch_sync(q, ^{
        NSLog(@"用户支付----- %@",[NSThread currentThread]);
    });
    for (int i = 0; i < 10; i ++) {
        NSLog(@"%d\n",i);
    }

    //3、下载
    dispatch_async(q, ^{
        NSLog(@"用户下载----- %@",[NSThread currentThread]);
    });
    NSLog(@"come here!");

打印

2018-04-03 13:43:05.538233+0800 GCD演示[1264:539460] 用户登录----- {number = 1, name = main}
2018-04-03 13:43:05.538480+0800 GCD演示[1264:539460] 用户支付----- {number = 1, name = main}
2018-04-03 13:43:05.538938+0800 GCD演示[1264:539460] 0
2018-04-03 13:43:05.539076+0800 GCD演示[1264:539460] 1
2018-04-03 13:43:05.539220+0800 GCD演示[1264:539460] 2
2018-04-03 13:43:05.539321+0800 GCD演示[1264:539460] 3
2018-04-03 13:43:05.539431+0800 GCD演示[1264:539460] 4
2018-04-03 13:43:05.539679+0800 GCD演示[1264:539460] 5
2018-04-03 13:43:05.540171+0800 GCD演示[1264:539460] 6
2018-04-03 13:43:05.540635+0800 GCD演示[1264:539460] 7
2018-04-03 13:43:05.541084+0800 GCD演示[1264:539460] 8
2018-04-03 13:43:05.541530+0800 GCD演示[1264:539460] 9
2018-04-03 13:43:05.541870+0800 GCD演示[1264:539460] come here!
2018-04-03 13:43:05.541957+0800 GCD演示[1264:540171] 用户下载----- {number = 3, name = (null)}
  • 因为登录和支付都是同步任务，在执行完同步任务之后才会开启子线程完成其他异步任务

思考：如果登录、支付和下载都是耗时任务，为了增强用户体验，不想将他们放在UI线程中，怎么样完成这三个任务的同步呢？
方法：将三个任务作为一个异步任务，这样不管放在串行队列或者并发队列中，GCD都会开辟子线程调度此任务，然后在开启的子线程上同步调度三个任务，就完成了异步中同步调度任务

  dispatch_queue_t q = dispatch_queue_create("chen", DISPATCH_QUEUE_CONCURRENT);
  //包装三个任务为block  异步执行
    void (^task)() = ^{
        dispatch_sync(q, ^{
            for (int i = 0; i < 10; i ++) {
                NSLog(@"%d--- %@\n",i,[NSThread currentThread]);
            }
        });

        //1、登录
        dispatch_async(q, ^{
            NSLog(@"用户登录----- %@",[NSThread currentThread]);
            
        });
        //2、支付
        dispatch_async(q, ^{
            NSLog(@"用户支付----- %@",[NSThread currentThread]);
        });

        
        //3、下载
        dispatch_async(q, ^{
            NSLog(@"用户下载----- %@",[NSThread currentThread]);
        });
    };
    dispatch_async(q, task);

打印

2018-04-03 13:54:32.628778+0800 GCD演示[1297:579094] 0--- {number = 4, name = (null)}
2018-04-03 13:54:32.628785+0800 GCD演示[1297:579087] 用户登录----- {number = 3, name = (null)}
2018-04-03 13:54:32.629000+0800 GCD演示[1297:579094] 1--- {number = 4, name = (null)}
2018-04-03 13:54:32.629150+0800 GCD演示[1297:579087] 用户支付----- {number = 3, name = (null)}
2018-04-03 13:54:32.629169+0800 GCD演示[1297:579094] 2--- {number = 4, name = (null)}
2018-04-03 13:54:32.629267+0800 GCD演示[1297:579094] 3--- {number = 4, name = (null)}
2018-04-03 13:54:32.629269+0800 GCD演示[1297:579087] 用户下载----- {number = 3, name = (null)}
2018-04-03 13:54:32.629835+0800 GCD演示[1297:579094] 4--- {number = 4, name = (null)}
2018-04-03 13:54:32.630147+0800 GCD演示[1297:579094] 5--- {number = 4, name = (null)}
2018-04-03 13:54:32.630346+0800 GCD演示[1297:579094] 6--- {number = 4, name = (null)}
2018-04-03 13:54:32.630643+0800 GCD演示[1297:579094] 7--- {number = 4, name = (null)}
2018-04-03 13:54:32.631249+0800 GCD演示[1297:579094] 8--- {number = 4, name = (null)}
2018-04-03 13:54:32.631599+0800 GCD演示[1297:579094] 9--- {number = 4, name = (null)}

这样所有的任务都会在子线程中执行，并且三个任务之间有依赖关系

  1. 全局队列
    GCD提供默认的并发队列供全局使用：全局队列。其获取方式和参数如下：
dispatch_get_global_queue(long identifier, unsigned long flags);
  参数类型为：
    long identifier：ios 8.0 告诉队列执行任务的“服务质量 quality of service”，系统提供的参数有：
     QOS_CLASS_USER_INTERACTIVE 0x21,              用户交互(希望尽快完成，用户对结果很期望，不要放太耗时操作)
     QOS_CLASS_USER_INITIATED 0x19,                用户期望(不要放太耗时操作)
     QOS_CLASS_DEFAULT 0x15,                        默认(不是给程序员使用的，用来重置对列使用的)
     QOS_CLASS_UTILITY 0x11,                        实用工具(耗时操作，可以使用这个选项)
     QOS_CLASS_BACKGROUND 0x09,                     后台
     QOS_CLASS_UNSPECIFIED 0x00,                    未指定
     iOS 7.0 之前 优先级
     DISPATCH_QUEUE_PRIORITY_HIGH 2                 高优先级
     DISPATCH_QUEUE_PRIORITY_DEFAULT 0              默认优先级
     DISPATCH_QUEUE_PRIORITY_LOW (-2)               低优先级
     DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN  后台优先级

    BACKGROUND表示用户不需要知道任务什么时候完成，如果选择这个选项速度慢得令人发指，非常不利于调试！对于优先级推荐不要搞得太负责，就用最简单，以免发生优先级反转。
     
    unsigned long flags：苹果官方文档是这样解释的： Flags that are reserved for future use。标记是为了未来使用保留的！所以这个参数应该永远指定为0

注意：全局队列属于并发队列，建议在企业级应用开发过程中如果不使用全局队列，尽量给队列起名，这样有利于错误跟踪；另外，在MRC模式下，队列需要releasedispatch_release(q);//ARC 情况下不需要release！

  1. 延时执行dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block); 
    /**参数
     1、when 时间
     2、queue
     3、Block
     */
    //从现在开始执行多少纳秒之后,让queue调度Block的任务并且异步执行
    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, 1.0 * NSEC_PER_SEC);
    dispatch_after(when, dispatch_queue_create("jinguo", NULL), ^{
        NSLog(@"%@",[NSThread currentThread]);
    });
  1. 执行一次dispatch_once(dispatch_once_t * _Nonnull predicate, ^(void)block) ;
    执行一次经常在单例中用到，是苹果提供的一次性机制，不仅能保证代码只执行一次，并且线程安全，线程安全表现在：dispatch_once_t * _Nonnull predicate参数，其原理官方头文件也有表现：
_dispatch_once(dispatch_once_t *predicate,
        DISPATCH_NOESCAPE dispatch_block_t block)
{
    if (DISPATCH_EXPECT(*predicate, ~0l) != ~0l) {
        dispatch_once(predicate, block);
    } else {
        dispatch_compiler_barrier();
    }
    DISPATCH_COMPILER_CAN_ASSUME(*predicate == ~0l);
}

其实具体是什么原理我也看不懂，毕竟C语言认识我我不认识它，其大概意思是我们外面定义的dispatch_once_t参数在传入这个函数之后，使用它来保证线程安全的，其实我们做一次打印也可以看出个大概

   for (int i = 0; i < 10; i ++) {
       dispatch_async(dispatch_get_global_queue(0, 0), ^{
           static dispatch_once_t onceToken;
           NSLog(@"%ld",onceToken);
           dispatch_once(&onceToken, ^{
               NSLog(@" %@come here！",[NSThread currentThread]);
           });
           NSLog(@"来了 ----%d %@",i,[NSThread currentThread]);
       });
   }

打印

2018-04-03 14:17:22.679810+0800 GCD演示[1372:683676] 0
2018-04-03 14:17:22.679816+0800 GCD演示[1372:683678] 0
2018-04-03 14:17:22.679810+0800 GCD演示[1372:682541] 0
2018-04-03 14:17:22.679866+0800 GCD演示[1372:683679] 0
2018-04-03 14:17:22.680138+0800 GCD演示[1372:683678]  {number = 3, name = (null)}come here！
2018-04-03 14:17:22.680170+0800 GCD演示[1372:683680] 5385
2018-04-03 14:17:22.680480+0800 GCD演示[1372:683681] 5385
2018-04-03 14:17:22.680785+0800 GCD演示[1372:683676] 来了 ----1 {number = 6, name = (null)}
2018-04-03 14:17:22.680785+0800 GCD演示[1372:682541] 来了 ----0 {number = 5, name = (null)}
2018-04-03 14:17:22.680795+0800 GCD演示[1372:683678] 来了 ----2 {number = 3, name = (null)}
2018-04-03 14:17:22.680805+0800 GCD演示[1372:683680] 来了 ----4 {number = 4, name = (null)}
2018-04-03 14:17:22.680813+0800 GCD演示[1372:683679] 来了 ----3 {number = 7, name = (null)}
2018-04-03 14:17:22.680992+0800 GCD演示[1372:683681] 来了 ----5 {number = 8, name = (null)}
2018-04-03 14:17:22.681220+0800 GCD演示[1372:683682] -1
2018-04-03 14:17:22.681490+0800 GCD演示[1372:683683] -1
2018-04-03 14:17:22.681692+0800 GCD演示[1372:683676] -1
2018-04-03 14:17:22.681766+0800 GCD演示[1372:683684] -1
2018-04-03 14:17:22.683852+0800 GCD演示[1372:683682] 来了 ----6 {number = 9, name = (null)}
2018-04-03 14:17:22.684087+0800 GCD演示[1372:683683] 来了 ----7 {number = 10, name = (null)}
2018-04-03 14:17:22.684468+0800 GCD演示[1372:683676] 来了 ----8 {number = 6, name = (null)}
2018-04-03 14:17:22.685031+0800 GCD演示[1372:683684] 来了 ----9 {number = 11, name = (null)}

onceToken的值一开始是0，执行到一次性语句时变为5385（或许是其他什么数），执行完毕变为-1，什么原理还望大神的指点。
还有一种一次性执行的方式：互斥锁 @synchronized()，在单例中用到过，下面将两种单例创建的方式列举一下，并比较两种方式创建单例的效率如何：

@synchronized()：

#import "Singleton.h"
static Singleton *_instance;
@implementation Singleton
+ (instancetype)share{
    return [[self alloc]init];
}
+ (instancetype)allocWithZone:(struct _NSZone *)zone{
    @synchronized(self){
        if (_instance == nil) {
            _instance = [super allocWithZone:zone];
        }
    }
    return _instance;
}
- (id)copyWithZone:(NSZone *)zone{
    return _instance;
}
- (id)mutableCopyWithZone:(NSZone *)zone{
    return _instance;
}
@end

onceToken：

#import "Singleton2.h"
static Singleton2 *_instance;

@implementation Singleton2
+ (instancetype)share{
    return [[self alloc]init];
}
+ (instancetype)allocWithZone:(struct _NSZone *)zone{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        if (_instance == nil) {
            _instance = [super allocWithZone:zone];
        }
    });
    return _instance;
}
- (id)copyWithZone:(NSZone *)zone{
    return _instance;
}
- (id)mutableCopyWithZone:(NSZone *)zone{
    return _instance;
}
@end

苹果推荐使用GCD的一次性，效率高，而互斥锁效率低,下面比较一下两种方式的执行时间就一目了然了：

    //@synchronized
    //获取代码开始执行时时间
    CFAbsoluteTime synBegin =CFAbsoluteTimeGetCurrent();
    //获取代码结束执行时时间
    Singleton *synSingle = [Singleton share];
    CFAbsoluteTime synEnd =CFAbsoluteTimeGetCurrent();
    //计算开始和结束的时间差,该时间差就是循环创建单例需要的时间
    NSLog(@"synchronized------%f",synBegin- synEnd);
    
    //onceToken
    //获取代码开始执行时时间
    CFAbsoluteTime onceBegin =CFAbsoluteTimeGetCurrent();
    //获取代码结束执行时时间
    Singleton2 *onceSingle = [Singleton share];
    CFAbsoluteTime onceEnd =CFAbsoluteTimeGetCurrent();
    //计算开始和结束的时间差,该时间差就是循环创建单例需要的时间
    NSLog(@"onceToken---------%f",onceBegin- onceEnd);

打印结果

2018-04-03 15:18:01.046723+0800 GCD演示[1580:939403] synchronized-------0.000021
2018-04-03 15:18:01.046944+0800 GCD演示[1580:939403] onceToken----------0.000004
  1. 调度组 dispatch_group_t
    GCD头文件group.h中谈到,可以将一组block提交到调度组（dispatch_group）中,执行逐个串行回调，下面来看看相关函数。

  • dispatch_group_t dispatch_group_create(void);
    创建一个调度组,释放调度组使用dispatch_release()函数,创建成功返回一个dispatch_group调度组，失败则返回NULL.

  • void dispatch_group_async(dispatch_group_t group,dispatch_queue_t queue,dispatch_block_t block);
    提交一个闭包函数（block）到queue中，并关联到指定的group调度组.通过typedef void (^dispatch_block_t)(void);我们可以发现，该函数无法给block传递参数.
    1.group 指定的调度组，block的关联调度组。
    2.queue 提交闭包函数（block)的队列。
    3.block 提交到指定queue的闭包函数block。

  • void dispatch_group_async_f(dispatch_group_t group,dispatch_queue_t queue,void *_Nullable context,dispatch_function_t work);
    提交一个函数指针(dispatch_function_t)到queue中，并关联到指定的group调度组,函数返回void.
    1.group 指定的调度组，block的关联调度组。
    2.queue 提交闭包函数（block)的队列。
    3.context 传递到函数中的的参数。
    4.work 在指定的queue中的指定函数。

  • long dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
    执行等待，等待所有关联到group调度组的block执行完成，或者等待timeout发生超时，当在超时时间timeout内执行完了所有的block函数,则返回0,否则返回非0值。
    1.group 给定调度组
    2.timeout 如果group调度组里边的block执行时间非常长，函数的等待时间.

  • void dispatch_group_notify(dispatch_group_t group,dispatch_queue_t queue,dispatch_block_t block);
    该函数指定了一个block,当group调度组里边的所有block都执行完成时，将通知block关联到group中，并加入到给定的queue队列里,当group调度组当前没有任何block关联的时候将立即将block提交到queue队列，并与group调度组关联,该函数返回void.
    1.group 给定的调度组
    2.queue 给定的队列.
    3.给定的闭包函数.

  • void dispatch_group_notify_f(dispatch_group_t group,dispatch_queue_t queue,void *_Nullable context,dispatch_function_t work);
    与disptch_group_notify类似,提交的一个函数work作为执行体，context是执行时传递的参数，该函数返回void.

  • void dispatch_group_enter(dispatch_group_t group);

  • void dispatch_group_leave(dispatch_group_t group);
    这一对函数调用一次意味着非使用dispatch_group_async方式，将一个block提交到指定的queue上并关联到group调度组.两个函数必须成对出现。

在实际开发中，需要开启N个异步线程，但是后续操作，需要依赖N个线程返回的数据，需要接收所有线程任务执行完成的通知。

    //1.对列
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);
    //2.调度组
    dispatch_group_t group = dispatch_group_create();
    //3.添加任务，让队列调度，任务执行情况，最后通知群组
    dispatch_group_async(group, q, ^{
        NSLog(@"Download A%@",[NSThread currentThread]);
    });
    dispatch_group_async(group, q, ^{
        sleep(1.0);
        NSLog(@"Download B%@",[NSThread currentThread]);
    });
    dispatch_group_async(group, q, ^{
        NSLog(@"Download C%@",[NSThread currentThread]);
    });
    //所有任务完成之后通知群组
    //用调度组，可以监听全局队列的任务，主队列去执行最后的任务
    //dispatch_group_notify 本身也是异步执行
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@" OK %@",[NSThread currentThread]);
    });
    NSLog(@"come here");

注：dispatch_group_notify这个函数是异步的，如果要换成同步用dispatch_group_wait(group, DISPATCH_TIME_FOREVER).群组不空，这句代码一直等，下面代码不执行

// 队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    // 调度组
    dispatch_group_t group = dispatch_group_create();
    
    // 1. 进入群组，给 group 打一个标记，在后续紧接着的 block 归 group 监听
    // dispatch_group_enter 和 dispatch_group_leave 必须成对出现！
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:10];
        NSLog(@"download A - %@", [NSThread currentThread]);
        // 耗时操作代码

        // 2. 离开群组
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:1.0];
        NSLog(@"download B - %@", [NSThread currentThread]);
        // 耗时操作代码

        // 2. 离开群组
        dispatch_group_leave(group);
    });
    
    // 等待群组空，一直到永远，群组不空，这句代码就死等，同步
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"OK");
  1. 主队列 dispatch_get_main_queue()
    主队列是用来在主线程上调度任务，会在程序开始时创建，只需要获取。
    异步任务
    //主队列 --> 已启动主线程就可以拿到主队列
    dispatch_queue_t q = dispatch_get_main_queue();
    //异步任务
    dispatch_async(q, ^{
        NSLog(@"%@",[NSThread currentThread]);
    });
    for (int i = 0; i < 10 ; i ++) {
        NSLog(@"come here");
    }

同步任务会造成死锁

    //崩溃！！！！！！
    dispatch_sync(q, ^{
        NSLog(@"%@",[NSThread currentThread]);
    });
    for (int i = 0; i < 10 ; i ++) {
        NSLog(@"come here");
    }

解决办法

    //主队列同步任务（不死锁）
    void (^task)() = ^{
        dispatch_queue_t q = dispatch_get_main_queue();
        //2.异步任务
        dispatch_sync(q, ^{
            NSLog(@"%@",[NSThread currentThread]);
        });
        for (int i = 0; i < 10 ; i ++) {
            NSLog(@"come here %@",[NSThread currentThread]);
        }
    };
    dispatch_async(dispatch_get_global_queue(0, 0), task);
更新中。。。。。。

你可能感兴趣的:(iOS进阶之多线程--GCD)

  • ios GCD _Waiting_
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
  • 多线程之——ExecutorCompletionService 阿福德
    在我们开发中，经常会遇到这种情况，我们起多个线程来执行，等所有的线程都执行完成后，我们需要得到个线程的执行结果来进行聚合处理。我在内部代码评审时，发现了不少这种情况。看很多同学都使用正确，但比较啰嗦，效率也不高。本文介绍一个简单处理这种情况的方法：直接上代码：publicclassExecutorCompletionServiceTest{@TestpublicvoidtestExecutorCo
  • python多线程程序设计 之一 IT_Beijing_BIT #Python程序设计语言python
    python多线程程序设计之一全局解释器锁线程APIsthreading.active_count()threading.current_thread()threading.excepthook(args,/)threading.get_native_id()threading.main_thread()threading.stack_size([size])线程对象成员函数构造器start/ru
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • Python多线程实现大规模数据集高效转移 sand&wich 网络python服务器
    背景在处理大规模数据集时，通常需要在不同存储设备、不同服务器或文件夹之间高效地传输数据。如果采用单线程传输方式，当数据量非常大时，整个过程会非常耗时。因此，通过多线程并行处理可以大幅提升数据传输效率。本文将分享一个基于Python多线程实现的高效数据传输工具，通过遍历源文件夹中的所有文件，将它们移动到目标文件夹。工具和库这个数据集转移工具主要依赖于以下Python标准库：os：用于文件系统操作，如
  • Python实现下载当前年份的谷歌影像 sand&wich python开发语言
    在GIS项目和地图应用中，获取最新的地理影像数据是非常重要的。本文将介绍如何使用Python代码从Google地图自动下载当前年份的影像数据，并将其保存为高分辨率的TIFF格式文件。这个过程涉及地理坐标转换、多线程下载和图像处理。关键功能该脚本的核心功能包括：坐标转换：支持WGS-84与WebMercator投影之间转换，以及处理中国GCJ-02偏移。自动化下载：多线程下载地图瓦片，提高效率。图像
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 经纬恒润二面&三七互娱一面&元象二面 Redstone Monstrosity 面试前端
    1.请尽可能详细地说明，进程和线程的区别，分别有哪些应用场景？进程间如何通信？线程间如何通信？你的回答中不要写出示例代码。进程和线程是操作系统中的两个基本概念，它们在计算机系统中扮演着不同的角色，并且在不同的应用场景中发挥作用。进程和线程的区别定义：进程：进程是操作系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间和系统资源。线程：线程是进程内的一个执行单元，是操作系统进行调度的最小单位
  • Redis Key的过期策略 ArchManual 分布式架构分布式Java后端微服务架构redis
    Redis的过期策略主要是指管理和删除那些设定了过期时间的键，以确保内存的有效使用和数据的及时清理。具体来说，Redis有三种主要的过期策略：定期删除（ScheduledDeletion）、惰性删除（LazyDeletion）和内存淘汰策略（EvictionPolicies）。1.定期删除Redis的定期删除策略（ScheduledDeletion）的步骤如下：设置定期任务：Redis会在后台线程
  • Redis:缓存击穿 我的程序快快跑啊 缓存redisjava
    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
  • 【java】怎么理解不同对象实例的对象锁是互不干扰的 晨春计 Androidjava
    在Java中，synchronized关键字用于实现线程同步，它可以作用于实例方法、静态方法以及代码块。当synchronized应用于实例方法或实例变量时，它创建的是一个对象锁，这个锁是与特定的对象实例关联的。因此，每个对象实例都有其自己的锁。这里的关键点在于，对象锁是绑定到特定对象实例上的。这意味着对于不同的对象实例，即使它们属于同一个类，它们各自拥有独立的对象锁。当一个线程获取了一个对象实例
  • 程序计数器的作用 毕加涛 java
    程序计数器的作用就是**用来记住下一条jvm指令的执行地址。**它的特点是**线程私有的**，也就是一人一个。然后cpu会给每个线程分配时间片，然后等待这个线程的时间片用完之后就会轮到下一个线程来执行。所以此时就需要计数器来记录线程运行的下一行指令的地址，等到下次轮到这个线程执行的时候来到上次执行的指令地址来继续执行指令。所以它的作用就是：为了保证程序的执行遵循自上而下有顺序的执行。
  • tcp线程进程多并发 @莫福瑞 算法
    tcp线程多并发#include#defineSERPORT8888#defineSERIP"192.168.0.118"#defineBACKLOG20typedefstruct{intnewfd;structsockaddr_incin;}BMH;void*fun1(void*sss){intnewfd=accept((BMH*)sss)->newfd;structsockaddr_incin
  • 保证RTOS线程安全的常规操作 WittXie 单片机嵌入式硬件
    线程安全定义原子操作：一种不可分割的操作，要么完全执行成功，要么完全不执行，不能被打断临界区：一段代码，这段代码需要在同一时间只允许一个线程执行互斥锁：一种用于保护共享资源的机制，确保同一时间只有一个线程可以访问特定资源应用裸机原子操作/临界区可以通过暂时关闭中断响应实现一般用不到互斥锁RTOS原子操作：暂时关闭中断响应+挂起所有应用（不建议，RTOS尽量不要开启中断，改为线程监听）临界区：挂起所
  • 单线程执行器（`SingleThreadedExecutor`）来处理节点的任务 课堂随想 moveit2机器人
    intmain(intargc,char**argv){rclcpp::init(argc,argv);rclcpp::NodeOptionsnode_options;node_options.automatically_declare_parameters_from_overrides(true);automove_group_node=rclcpp::Node::make_shared("mo
  • golang学习笔记--MPG模型 xxzed golang#学习笔记学习笔记golang
    MPG模式：M（Machine）：操作系统的主线程P（Processor）：协程执行需要的资源（上下文context），可以看作一个局部的调度器，使go代码在一个线程上跑，他是实现从N：1到N：M映射的关键G（Goroutine）：协程，有自己的栈。包含指令指针（instructionpointer）和其它信息（正在等待的channel等等），用于调度。一个P下面可以有多个G1、当前程序有三个M,
  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • 【C#Mutex】 initiallyOwned错误引起的缺陷 闻缺陷则喜何志丹 c#互斥量进程同步WaitOneinitiallyOwned临界区
    临界区只能对同一个进程的不同线程同步，互斥量可以跨进程同步。典型应用场景：两个exe会操作同一个注册表项。错误代码封装类publicclassCMutexHelp:IDisposable{publicCMutexHelp(){s_mutex.WaitOne();}privatestaticMutexs_mutex=newMutex(true,"Time202409091406ab");public
  • [面试高频问题]关于多线程的单例模式 朱玥玥要每天学习 java单例模式开发语言
    单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
  • [Golang] goroutine 沉着冷静2024 Golanggolang后端
    [Golang]goroutine文章目录[Golang]goroutine并发进程和线程协程goroutine概述如何使用goroutine并发进程和线程谈到并发，大多都离不开进程和线程，什么是进程、什么是线程？进程可以这样理解：进程就是运行着的程序，它是程序在操作系统的一次执行过程，是一个程序的动态概念，进程是操作系统分配资源的基本单位。线程可以这样理解：线程是一个进程的执行实体，它是比进程粒
  • Spring @Async 深度解读：默认线程池执行器的配置与优化 小码快撩 springjava前端
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
  • Rides实现分布式锁，保障数据一致性,Redisson分布式事务处理 朱杰jjj 缓存分布式
    分布式环境下分布式锁有三种方式：基于数据库分布式锁基于Redis分布式锁基于zk分布式锁本帖只介绍Redis分布式锁为什么需要用到分布式锁？在单机环境下一个服务中多个线程对同一个事物或数据资源进行操作时，可以通过添加加锁方式（synchronized和lock）来解决数据一致性的问题。但是如果出现多个服务的情况下，这时候我们在通过synchronized和lock的方式来加锁会出现问题，因为多个服
  • 连接池的性能如何优化？ 蜡笔小新星 MySQL经验分享学习pythonmysql数据库
    连接池的性能优化是提高数据库访问效率和应用程序响应速度的关键。以下是一些优化连接池性能的策略：1.选择合适的连接池大小连接池的大小应根据应用程序的并发需求和数据库服务器的处理能力来确定。如果连接池太小，可能会导致线程等待连接；如果连接池太大，可能会消耗过多的系统资源。通常，连接池的大小应该设置为应用程序的并发用户数加上一些额外的连接以处理突发请求。2.设置合理的最小和最大连接数最小连接数（mins
  • 基于flask做大模型SSE输出 Mark_Aussie nlpflaskpython后端
    默认情况下，Fask以多线程模式运行，每个请求都落在一个新线程上。SSE：基于HTTP的协议，用于实现服务器向客户端推送实时数据。使用长轮询机制，客户端通过HTTP连接向服务器发送请求，并保持该连接打开，服务器可以随时向客户端推送新的数据。SSE协议使用简单的文本格式，数据通过纯文本的消息流进行传输，每个消息以"data:"开头，以两个换行符"\n\n"结尾，如果传递的数据中有字典要使用变量传递。
  • Vector与Stack简述 Sun_Jingjing Java集合
    Vector：线程安全，默认容量为10，容量增长量默认为0，每次进行扩容是旧的容量乘以2。支持null的添加。基于数组实现。Stack：Stack继承Vector的栈结构。
  • 为什么Node.js不适合CPU密集型应用？ weixin_54503231 node.js
    Node.js不适合CPU密集型应用的原因主要基于其设计理念和核心特性，具体可以归纳为以下几点：单线程模型Node.js采用单线程模型来处理用户请求和异步I/O操作。虽然这种模型在处理高并发I/O密集型任务时非常高效，因为它避免了传统多线程模型中的线程上下文切换开销，但这也意味着它不能充分利用现代多核CPU的计算能力。对于需要大量计算资源的CPU密集型应用，单线程模型会成为瓶颈，导致应用性能受限。
  • 明初四大案之空印案 鹤舞春风
    空印案是明初四大案中一个彻头彻尾的冤案。但是牵连之多，影响之大，实属罕见。此案发生在洪武九年。明朝规定，各地每年都要派人入京报告地方财政账目，地方账目要求必须跟户部审核完全相符。如果对不上，哪怕错了一个数字，也要发回重新填制，而且所有账目必须有原来的衙门公章压印有效。这在当时来说，是一件十分为难、十分麻烦的事情。各地使者带着账目去京城对账，一路风餐露宿，辛苦异常，需要不断的骑马、坐船，甚至有的地方
  • Java内存模型基础 2401_84002271 程序员java学习经验分享
    1.2Java内存模型的抽象结构Java中所有的实例域、静态域和数组元素都存储在堆内存中，堆内存在线程之间共享（文章中用“共享变量”指代）。局部变量(LocalVariables)、方法定义参数(FormalMethodParameters)和异常处理器参数(ExceptionHandlerParameters)不会在线程之间共享，它们不会存在内存可见性问题，因此也不受内存模型的影响。Java线程
  • Spring Cloud: Hystrix请求队列线程不足 MeazZa
    在SpringCloud中，Feign可以实现本地化的微服务API调用，Hystrix可以实现调用失败时的fallback处理。问题描述：在实际生产环境中使用时，我们遇到了这样一个错误："...,stacktrace:[com.netflix.hystrix.exception.HystrixRuntimeException:QueryNodeImpalaBdService#getQueryRes
  • Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理） 致碑前繁花 刷题记录c语言c++开发语言
    什么？竟然是裴蜀定理。。。由于这里给出了a和b两个数，我们或许可以想到使用同样是需要给出两个定值的裴蜀定理，即：如果给定xxx和yyy，那么一定有ax+by=gcd(x,y)ax+by=gcd(x,y)ax+by=gcd(x,y)。所以在这时候我们就可以让输入的所有数都去对gcd(a,b)gcd(a,b)gcd(a,b)取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去aaa和bb
  • ASM系列四 利用Method 组件动态注入方法逻辑 lijingyao8206 字节码技术jvmAOP动态代理ASM
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
  • java编程思想 --内部类 百合不是茶 java内部类匿名内部类
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅   1,内部类的创建  内部类是创建在类中的 package com.wj.InsideClass; /* * 内部类的创建 */ public class CreateInsideClass { public CreateInsideClass(
  • web.xml报错 crabdave web.xml
    web.xml报错   The content of element type "web-app" must match "(icon?,display-  name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
  • 泛型类的自定义 麦田的设计者 javaandroid泛型
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 采用泛型类，完成扩展。   例如有一个学生类     Student{ Student(){ System.out.println("I'm a student....."); } }  有一个老师类  
  • CSS清除浮动的4中方法 IT独行者 JavaScriptUIcss
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 1、结尾处加空div标签 clear:both 1 2 3 4 .div 1 { background : #000080 ; border : 1px   s
  • Cygwin使用windows的jdk 配置方法 _wy_ jdkwindowscygwin
    1.[vim /etc/profile]    JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43)    PATH="$JAVA_HOME/bin:${PATH}"    CLAS
  • linux下安装maven 无量 mavenlinux安装
    Linux下安装maven(转) 1.首先到Maven官网 下载安装文件，目前最新版本为3.0.3，下载文件为 apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 2.进入下载文件夹，找到下载的文件，运行如下命令解压 tar -xvf  apache-maven-2.2.1-bin.tar.gz 解压后的文件夹
  • tomcat的https 配置,syslog-ng配置 aichenglong tomcathttp跳转到httpssyslong-ng配置syslog配置
    1) tomcat配置https,以及http自动跳转到https的配置     1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令)      keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
  • 关于领号活动总结 alafqq 活动
    关于某彩票活动的总结 具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 活动要求 1，随机性，一定要有随机性； 2，最少中奖概率，如果注数为3200注，则最多中4注 3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 解决方案 1，事先产生随机数1000个，并打
  • java数据结构 冒泡排序的遍历与排序 百合不是茶 java
    java的冒泡排序是一种简单的排序规则   冒泡排序的原理：           比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样；         针对所有的元素重复以上的步骤，除了最后一个     例题；将int array[]
  • JS检查输入框输入的是否是数字的一种校验方法 bijian1013 js
    如下是JS检查输入框输入的是否是数字的一种校验方法： <form method=post target="_blank"> 数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br> </form>
  • Test注解的两个属性：expected和timeout bijian1013 javaJUnitexpectedtimeout
    JUnit4：Test文档中的解释： 　　The Test annotation supports two optional parameters. 　　The first, expected, declares that a test method should throw an exception. 　　If it doesn't throw an exception or if it
  • [Gson二]继承关系的POJO的反序列化 bit1129 POJO
    父类     package inheritance.test2; import java.util.Map; public class Model { private String field1; private String field2; private Map<String, String> infoMap
  • 【Spark八十四】Spark零碎知识点记录 bit1129 spark
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中  
  • WAS各种脚本作用大全 ronin47 WAS 脚本
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 　　　 获取下载 这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句 bylijinnan switch
    借鉴网上的思路，用java实现： public class NoIfWhile { /** * @param args * * find x=1+2+3+....n */ public static void main(String[] args) { int n=10; int re=find(n); System.o
  • Netty源码学习-ObjectEncoder和ObjectDecoder bylijinnan javanetty
    Netty中传递对象的思路很直观： Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 那把对象序列化为字节流，就可以在Netty中传递对象了 相应的从ChannelBuffer恢复对象，就是反序列化的过程 Netty已经封装好ObjectEncoder和ObjectDecoder 先看ObjectEncoder ObjectEncoder是往外发送
  • spring 定时任务中cronExpression表达式含义 chicony cronExpression
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 代表含义            是否必须 允许的取值范围         &nb
  • Nutz配置Jndi ctrain JNDI
    1、使用JNDI获取指定资源： var ioc = { dao : { type :"org.nutz.dao.impl.NutDao", args : [ {jndi :"jdbc/dataSource"} ] } } 以上方法,仅需要在容器中配置好数据源,注入到NutDao即可.
  • 解决 /bin/sh^M: bad interpreter: No such file or directory daizj shell
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。   分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 解决： 1）在windows下转换： 利用一些编辑器如UltraEdit或EditPlus等工具
  • [转]for 循环为何可恨？ dcj3sjt126com 程序员读书
      Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
  • Android实用小技巧 dcj3sjt126com android
    1、去掉所有Activity界面的标题栏 　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar"   2、去掉所有Activity界面的TitleBar 和StatusBar  　　修改AndroidManifes
  • Oracle 复习笔记之序列 eksliang Oracle 序列sequenceOracle sequence
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 1.序列的作用 序列是用于生成唯一、连续序号的对象 一般用序列来充当数据库表的主键值 2.创建序列语法如下：   create sequence s_emp start with 1 --开始值 increment by 1 --増长值 maxval
  • 有“品”的程序员 gongmeitao 工作
    完美程序员的10种品质　　   完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的   完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强   （范围：用简单方式解决复杂问题）　　
  • 使用KeleyiSQLHelper类进行分页查询 hvt sql.netC#asp.nethovertree
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
  • SVG 教程 （三）圆形，椭圆，直线 天梯梦 svg
    SVG <circle> SVG 圆形 - <circle> <circle> 标签可用来创建一个圆： 下面是SVG代码： <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> <circle cx="100" c
  • 链表栈 luyulong java数据结构
    public class Node { private Object object; private Node next; public Node() { this.next = null; this.object = null; } public Object getObject() { return object; } public
  • 基础数据结构和算法十：2-3 search tree sunwinner Algorithm2-3 search tree
      Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
  • spring配置定时任务 stunizhengjia springtimer
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到：     //------------------------定时任务调用的方法------------------------------ /** * 存储过程定时器 */ publi
  • ITeye 8月技术图书有奖试读获奖名单公布 ITeye管理员 活动
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 8月试读活动回顾： http://webmaster.iteye.com/blog/2102830 本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 《跨终端Web》 gleams：http
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他