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

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)

  • 学习JavaEE的日子 Day32 线程池 A 北枝 学习JavaEE学习java-eejava线程池
    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】 还算善良_ 私有代码库工具类javalist数据结构
    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
  • C#中的PLINQ和LINQ的效率对比 搬砖的诗人Z C#c#linq开发语言
    PLINQ（ParallelLINQ）和LINQ（LanguageIntegratedQuery）都是.NET框架中的功能，用于对集合进行查询和操作。它们之间的主要区别在于并行处理能力。LINQ:LINQ是一种用于在.NET应用程序中进行数据查询和操作的语言集成功能。它提供了一种统一的方式来查询各种数据源，如集合、数组、XML、数据库等。LINQ是在单线程环境中执行查询操作的，因此对于大型数据集或
  • chrome扩展，“manifest_version“: 3, chrome 扩展图标点击事件 徐同保 chrome前端
    在Chrome扩展中，从ManifestV3开始，后台脚本（backgroundscripts）被服务工作线程（serviceworkers）所取代。这改变了扩展图标点击事件（通常称为浏览器操作或者页面操作）的处理方式。在ManifestV3中，您需要使用chrome.action.onClicked监听器来处理扩展图标的点击事件。下面是一个如何设置扩展图标点击事件处理器的示例：在manifest
  • 【转载】SSD测试第一神器——FIO running_sheep
    转自：[http://www.ssdfans.com]对于SSD性能测试来说，最好的工具莫过于FIO了。FIO是Jens开发的一个开源测试工具，功能非常强大，本文就只介绍其中一些基本功能。线程，队列深度，Offset，同步异步，DirectIO，BIO使用FIO之前，首先要有一些SSD性能测试的基础知识。线程指的是同时有多少个读或写任务在并行执行，一般来说，CPU里面的一个核心同一时间只能运行一个
  • C语言pthread互斥锁(mutex)和可重入锁(递归锁recursive)的演示 嫦娥妹妹等等我 开发语言c语言
    实验理论参考:1一旦共享资源被互斥锁锁定,则其余线程想访问共享资源必须等待，直到锁被释放2使用normal属性的互斥锁,一旦发生重入逻辑,则阻塞,成为死锁需要将属性改为recursive成为可重入的,递归的代码功能:1命令行传参1model=1演示异步未上锁之乱序演示count在数据竞态（RaceCondition）下的错误值2命令行传参2model=2演示使用互斥锁后线程的执行顺序演示count
  • C语言演示多线程编程条件下自旋锁和屏障的使用 嫦娥妹妹等等我 开发语言c语言开源
    主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • 突破编程_C++_C++11新特性（多线程编程的原子操作（2）） breakthrough_01 c++算法
    1std::atomic的加载与存储操作加载和存储操作是std::atomic最基础的两种操作。加载操作加载操作是通过load成员函数实现的，它用于从原子变量中读取一个值。这个函数可以确保在读取过程中，不会被其他线程打断。std::atomicatomic_var(10);//初始化一个原子变量，初始值为10intvalue=atomic_var.load();//原子加载操作，将atomic_v
  • 简单介绍synchronized的三种锁机制 才艺のblog javajvm开发语言
    synchronized一共有三种锁机制，分别是偏向锁、轻量级锁、重量级锁下面来简单介绍一下这三种锁机制：1、偏向锁：偏向锁对应了synchronized中锁只会被一个线程持有的情况，在第一次获取锁对象的时候会进行一次CAS操作，之后该线程再次获取锁对象的时候将只在markword中进行线程id的判断是否为本线程即可，而不会再去进行多余的CAS操作。2、轻量级锁：轻量级锁对应了synchroniz
  • 并发环境下wait与sleep的区别 才艺のblog java数据库
    1、归属问题sleep是Thread类的静态方法而wait是object的成员方法2、唤醒问题执行sleep(long)和wait(long)的线程都会在等待相应毫秒后醒来wait(long)/wait()可以被notify()/notifyAll()唤醒，但sleep(long)只会等待时间结束3、锁释放问题wait方法的调用必须先获取wait对象的锁，而sleep则无此限制wait方法执行后会
  • java线程之Lock的使用 dimdark
    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
  • Netty服务器结合WebSocke协议监听和接收数据 beiback 服务器问题Java服务器运维netty
    目录1.pom依赖2.配置属性3.创建netty服务器4.建立监听和响应5.创建启动器6.前端static下页面7.前端js8.注意异常问题9.创建netty服务器--使用守护线程1.pom依赖io.nettynetty-all4.1.86.Final2.配置属性application.properties#启动端口server.port=8088server.servlet.context-pa
  • list分组，多线程处理数据入库 墨玉加菲 java后端javaspring
    需求：解析上传的文件，将文件里的数据放入到list后，验证数据，符合条件的数据入库，分组多线程处理数据，有异常回滚事务（这里使用的是手动事务）先贴代码，这是业务代码packagecom.sh.service.test.impl;importcom.baomidou.mybatisplus.extension.service.impl.ServiceImpl;importcom.sh.constan
  • 基于 JMeter API 开发性能测试平台 咖啡加剁椒⑦ 软件测试jmeter功能测试软件测试自动化测试程序人生职场和发展
    背景：JMeter是一个功能强大的性能测试工具，若开发一个性能测试平台，用它作为底层执行引擎在合适不过。如要使用其API，就不得不对JMeter整个执行流程，常见的类有清楚的了解。常用的JMeter类和功能的解释：TestPlan类：代表一个测试计划，它是性能测试的顶级元素。您可以使用它来设置全局的测试属性，如测试名称、线程组、监听器等。ThreadGroup类：代表线程组，它定义了并发执行的线程
  • Java学习笔记：atomic的实现原理？ 曲钟人散
    在多线程的场景中，我们需要保证数据安全，就会考虑同步的方案，通常会使用synchronized或者lock来处理，使用了synchronized意味着内核态的一次切换。这是一个很重的操作。有没有一种方式，可以比较便利的实现一些简单的数据同步，比如计数器等等。concurrent包下的atomic提供我们这么一种轻量级的数据同步的选择。classMyThreadimplementsRunnable{
  • 安全点安全区的通俗理解 来自宇宙的曹先生 JVM垃圾回收GC
    想象一下，JVM（Java虚拟机）是一个忙碌的工厂，而Java程序中的线程就像是工厂里的工人。在这个工厂中，有时需要进行一些大规模的清理工作，比如垃圾回收，来确保工厂运行得更加高效。但是，如果在清理过程中所有的工人都继续他们的工作，可能会引发一些问题，比如有些工人可能正在使用一些即将被清理的资源。为了避免这类问题，JVM引入了“安全点（Safepoint）”和“安全区（SafeRegion）”的概
  • 【C++】学习记录--Thread线程库的使用 KK虫 c++
    线程是进程的一个执行路径，是CPU调度与分配的的最小单元。创建线程需要一个可调用的函数或者函数对象作为线程的入口。C++11中可以通过函数指针/函数对象或者lambda表达式实现。基本语法#includethreadt(function_name,args...)'function_name'为程序入口点'args'为传递给函数的参数线程创建后，可以使用't.join*()'等待线程完成，或使用'
  • jmeter获取返回json参数个数 海纳百川_9dc7
    我们在用jmeter做测试的时候，返回很多json数据，然后呢想要从中取出某个参数的数量，人工取数的情况下，会很繁琐。因此必须借助正则提取器。操作如下：配置线程组：然后配置正则表达式提取器：2转载：正则表达式提取器说明再用jmeter后置BeanShellPostProcessor3importcom.eclipsesource.json.*;importjava.util.regex.Match
  • 设计模式:单例模式 lucky_goose 设计模式单例模式设计模式
    单例模式应用场景懒汉模式饿汉模式单例模式应用场景当类的实例只能有一个时，使用单例模式懒汉模式懒汉模式指在第一次获取实例时，才对实例进行初始化//线程不安全的懒汉模式classSingleTon{private://静态成员变量，类内声明，类外初始化staticSingleTon*instance;//构造函数私有化SingleTon(){}SingleTon(constSingleTon&tmp)
  • 无锁队列（Lock-Free Queue） 笨死de猪 游戏服务器架构开发语言c++无锁队列
    一、什么是无锁队列无锁队列（Lock-FreeQueue）是一种不使用锁机制（如互斥锁或读写锁）来实现线程安全的数据结构，是lock-free中最基本的数据结构。它通过复杂的原子操作（如CAS操作，在C++中，可以使用std::atomic库提供的原子操作）来确保在多线程环境下的正确性和一致性。无锁队列的设计目标是在高并发场景下提供高性能的入队和出队操作，避免了锁机制带来的性能开销和潜在的死锁问题
  • 认识Java语言（一） 小魏冬琅 学习java开发语言
    Java语言的背景(0.1)在数字化的时代浪潮中，Java显得尤为璀璨，它不仅仅是由SunMicrosystems公司孕育而出的一种编程语言，更是一种融汇简洁性、面向对象的设计、分布式编程能力、稳健与安全性、平台独立性、可移植性、多线程处理能力和动态性于一体的技术精粹。Java之所以独树一帜，得益于它那“一次编写，随处运行”的核心理念，使其不仅成为编程语言的代名词，更是一个全方位的开发平台，提供了
  • MySQL Enterprise Backup (MEB) for MySQL 8.0 深入解析及企业级备份恢复演练 lzyever MySQLmysql数据库
    一、备份恢复核心概念MEB简介MySQLEnterpriseBackup是Oracle提供的专业物理备份工具，专为MySQL8.0及以后版本设计，提供高效且低干扰的在线备份解决方案。它能够实现对InnoDB存储引擎数据的快速备份，并兼容MySQL的诸多高级特性。主要特点在线热备份:MEB在备份期间尽可能减少对数据库活动的阻塞，采用多线程技术并结合InnoDB的元组锁定机制，创建一致性备份。增量备份
  • JAVA线程究竟有几种状态？ KK_crazy java线程状态数据库面试javatomcat开发语言
    线程状态全套面试题已打包2024最全大厂面试题无需C币点我下载或者在网页打开线程的状态，在你*度的过程中，你会发现，答案有5种，6种，甚至还有7种的，那么究竟有几种状态？准确答案就是6种在编译器JDK1.5以后的环境下，打开Thread进入源码看看：*Athreadstate.Athreadcanbeinoneofthefollowingstates:*一个线程，有以下几种状态**{@link#N
  • 春招面试高频题目总结 小杰312 面试笔试面试c++职场和发展学习
    面试问题redis可以用于进程间通信吗？Why？How?--->延展一下有哪些进程间通信技术,优劣如何？有大量的插入sql语句，一条条的插入性能很差，如何通过事务进行优化？保证线程安全的策略有哪些？你知道哪些设计模式？有什么理解？单例、工厂方法、责任链、模板方法、策略模式都是基类抽象固定方法。子类提供具体实现。如何实现服务端与客户端的即时通讯？消息队列如何保证这个消息一定执行？不会丢失？持久化消息
  • 操作系统-进程 线程 协程 迷路剑客 javalinuxjvm
    操作系统-进程线程协程概述进程、线程和协程都是程序执行过程中的不同调度实体，它们之间有以下区别：进程（Process）进程是操作系统资源分配和管理的基本单位它包含了运行程序所需的所有资源，如内存空间、文件句柄、系统资源等。进程之间相互独立它直接申请独立的内存空间，并且由操作系统负责管理和调度，不会直接影响其他进程的内存空间，因此进程间的数据不共享。一个进程的崩溃不会影响其他进程的执行。进程之间的通
  • 每日三个JAVA经典面试题(十六) 金克斯在coding java面试开发语言
    1.AQS对资源的共享方式？AbstractQueuedSynchronizer（AQS）是Java并发包中的一个关键框架，用于构建锁和其他同步器。AQS提供了对资源共享方式的支持，主要分为两种模式：独占模式和共享模式。这两种模式决定了同步状态（即资源）的获取和释放方式。独占模式（ExclusiveMode）独占模式意味着每次只有一个线程可以获取同步状态。这种模式适用于实现互斥锁等同步器，例如Re
  • python中的async和await用法 马鹤宁 python
    文章目录任务处理方式异步操作的优缺点async和awiatasyncawait使用async/await的注意事项示例前言：此篇文章是在文心一言的辅助下完成的。任务处理方式同步操作：同步操作是指所有的操作都完成后，才返回给用户结果。当一个任务发出请求并等待响应时，如果未收到响应，该任务就会被阻塞，并一直等待直到收到响应为止。例如，在一个同步过程中，如果有一个函数需要较长时间才能返回结果，那么主线程
  • 【死磕Java并发】—–深入分析volatile的实现原理 Zal哥哥
    通过前面一章我们了解了synchronized是一个重量级的锁，虽然JVM对它做了很多优化，而下面介绍的volatile则是轻量级的synchronized。如果一个变量使用volatile，则它比使用synchronized的成本更加低，因为它不会引起线程上下文的切换和调度。Java语言规范对volatile的定义如下：Java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，
  • 安卓面试题多线程 81-85 ️ 邪神 Android面试题java开发语言Android面试面试题多线程
    81.共享变量在多线程下如何保证线程安全？因为多线程是交替执⾏，每个线程操作共享变量时可能会导致数据不⼀致，要确保线程安全，需要在访问共享变量时添加同步机制。当然，如果这个变量本⾝是线程安全的，⽐如AtomicLong，那么多线程访问也是安全的82.Java中是否共享变量都使⽤类似AtomicLong原⼦安全类，多线程访问就是安全的？这个不确定，因为⽆法保证多个变量同时操作，⼀个原⼦变量可以保证⾃
  • 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其他