doudo
doudo

iOS-GCD

一、GCD的API

1. Dispatch queue

在执行处理时存在两种Dispatch queue：

  • 等待现在执行中任务结束的Serial Dispatch queue
  • 不等待现在执行中任务结束的Concurrent Dispatch queue
  1. Serial Dispatch queue：一个Serial Dispatch queue只生成并使用一个线程，顺序执行。
  2. Concurrent Dispatch queue：使用多个线程同时执行多个处理。XNU内核决定当前应当使用的线程数。

2. 如何生成Serial Dispatch queue和Concurrent Dispatch queue

1. dispatch_queue_create
  1. 第一种方式是通过dispatch_queue_create函数可生成Dispatch queue：
//Serial Dispatch queue
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.test.serialDispatchQueue", NULL);
    
//Concurrent Dispatch queue
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.test.concurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
  • 第一个参数指定Dispatch queue的名称，推荐使用应用程序ID这种逆序全域名，该名称会在Xcode和Instruments的调试器中作为Dispatch queue名称表示，另外也会出现的CrashLog中。如果嫌麻烦可以设为NULL，但调试中你一定会后悔没有署名。
  • 第二个参数设置为NULL，生成Serial Dispatch queue；设置为DISPATCH_QUEUE_CONCURRENT，生成Concurrent Dispatch queue。
  1. 只在为了避免多个线程更新相同资源导致数据竞争时使用Serial Dispatch queue。当使用create方法生成Serial Dispatch queue时，每生成一个Serial Dispatch queue，就会生成一个线程。如果过多使用多线程，就会消耗大量内存，引起大量的上下文切换，大幅度的降低系统的响应性能。所以不能激动几下大量生成Serial Dispatch queue。
    当想并行执行并且不会发生数据竞争等问题时使用Concurrent Dispatch queue。对于Concurrent Dispatch queue来说，不管生成多少个，由于XNU内核只使用有效管理的线程，因此不会发生Serial Dispatch queue那些问题。
  2. 由于Dispatch queue并没有像Block那样具有作为oc对象来处理的技术，所以通过dispatch_queue_create函数生成的Dispatch queue在使用结束后，需要通过dispatch_release函数来释放。不过ARC下现在已经不用处理，从iOS几开始？待查明。
2. Main Dispatch Queue/Global Dispatch Queue

第二种方法是获取系统标准提供的Dispatch queue：Main Dispatch Queue和Global Dispatch Queue。

  • Main Dispatch Queue，是在主线程中执行的Dispatch Queue。因为主线程只有一个，所以它自然也就是Serial Dispatch queue。
    追加到Main Dispatch Queue的处理在主线程的RunLoop中执行。因此要将用户界面的界面更新等一些必须在主线程中执行的处理追加到Main Dispatch Queue使用。
  • Global Dispatch Queue是整个应用程序都能使用的Concurrent Dispatch queue。Global Dispatch Queue有4个执行优先级，分别是高优先级、默认优先级、低优先级、后台优先级。

具体生成代码如下：

dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
    
    dispatch_queue_t globalDispatchQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    dispatch_queue_t globalDispatchQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_queue_t globalDispatchQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

3. dispatch_set_target_queue

每一个你创建的队列都必须有一个目标队列。默认情况下， 是优先级为DISPATCH_QUEUE_PRIORITY_DEFAULT的全局并发队列。
拥有一个目标队列对一个普通的队列来说有什么意义呢？答案可能有点令人意外：队列里每一个准备好要执行的block，将会被重新加入到这个队列的目标队列里去执行。
但是等一下，我们不是一直假设block就在其所在的队列里执行吗？难道这都是骗人的吗？
也不见得。因为所有新建的的队列会把默认优先级的全局并发队列当做其目标队列，所以不管哪一个队列上，任何一个准备好将要执行的block基本上都会立即执行。除非你改变队列的目标队列，否则这些block看起来就是在你的队列中执行的。

你的队列继承了其目标队列的优先级。将你的队列的目标队列改为更高或更低优先级的全局并发队列，能有效的改变你的队列的优先级。

只有全局并发队列和主队列才能执行block。其他所有的队列最终都必须设置其中一个为它的目标队列。

上面的引用出自：【译】GCD目标队列（GCD Target Queues）

为此做了下测试：

dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);//串行队列
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_SERIAL);//串行队列
    dispatch_queue_t queue3 = dispatch_queue_create("queue3", DISPATCH_QUEUE_SERIAL);//串行队列
    
    dispatch_queue_t globalQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);//并发队列
    dispatch_set_target_queue(queue1, globalQueueHigh);
    dispatch_set_target_queue(queue2, globalQueueHigh);
    dispatch_set_target_queue(queue3, globalQueueHigh);
    
    
    dispatch_async(queue1, ^{
        NSLog(@"queue1job1 in");
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"queue1job1 out");
    });
    dispatch_async(queue1, ^{
        NSLog(@"queue1job2 in");
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"queue1job2 out");
    });
    dispatch_async(queue1, ^{
        NSLog(@"queue1job3 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"queue1job3 out");
    });
    
    dispatch_async(queue2, ^{
        NSLog(@"queue2job1 in");
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"queue2job1 out");
    });
    dispatch_async(queue2, ^{
        NSLog(@"queue2job2 in");
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"queue2job2 out");
    });
    dispatch_async(queue2, ^{
        NSLog(@"queue2job3 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"queue2job3 out");
    });
    
    dispatch_async(queue3, ^{
        NSLog(@"queue3job1 in");
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"queue3job1 out");
    });
    dispatch_async(queue3, ^{
        NSLog(@"queue3job2 in");
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"queue3job2 out");
    });
    dispatch_async(queue3, ^{
        NSLog(@"queue3job3 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"queue3job3 out");
    });

输出：

2017-09-07 10:55:16.208 GCDTest[43628:4071278] queue1job1 in
2017-09-07 10:55:16.208 GCDTest[43628:4071276] queue3job1 in
2017-09-07 10:55:16.208 GCDTest[43628:4071290] queue2job1 in
2017-09-07 10:55:18.211 GCDTest[43628:4071278] queue1job1 out
2017-09-07 10:55:18.211 GCDTest[43628:4071290] queue2job1 out
2017-09-07 10:55:18.211 GCDTest[43628:4071276] queue3job1 out
2017-09-07 10:55:18.211 GCDTest[43628:4071278] queue1job2 in
2017-09-07 10:55:18.211 GCDTest[43628:4071290] queue2job2 in
2017-09-07 10:55:18.211 GCDTest[43628:4071276] queue3job2 in
2017-09-07 10:55:19.212 GCDTest[43628:4071276] queue3job2 out
2017-09-07 10:55:19.212 GCDTest[43628:4071290] queue2job2 out
2017-09-07 10:55:19.212 GCDTest[43628:4071278] queue1job2 out
2017-09-07 10:55:19.213 GCDTest[43628:4071276] queue3job3 in
2017-09-07 10:55:19.213 GCDTest[43628:4071290] queue2job3 in
2017-09-07 10:55:19.213 GCDTest[43628:4071278] queue1job3 in
2017-09-07 10:55:22.216 GCDTest[43628:4071276] queue3job3 out
2017-09-07 10:55:22.216 GCDTest[43628:4071278] queue1job3 out
2017-09-07 10:55:22.216 GCDTest[43628:4071290] queue2job3 out

经过实验与思考之后，我觉得可以这样理解（如果不正确，请留言指正，多谢）：

  • 如果这些队列的目标队列是并发队列，那么队列在注入到目标队列的时候，这些队列之间还是并发的，具体每个队列内部是并发还是顺序执行保持不变。可以看出，这些队列在重新指定目标队列为全局并发队列之后，队列之间的关系并没有改变，仍然是并发，因为默认的他们的目标队列就是Concurrent Dispatch Queue，只是可以改变优先级而已，个人觉得重新设置目标队列为全局并发队列的情况不多。
  • 如果这些队列的目标队列是Serial Dispatch Queue，那么这些队列在注入到目标队列的时候，所有队列中的任务都会按注入队列的先后顺序同步执行（即同时只能执行一个任务）。

理解了目标队列，我们看看怎么使用的：

  1. 通过dispatch_queue_create函数生成Dispatch Queue不管是Serial Dispatch Qeueu还是Concurrent Dispatch Queue，默认的优先级都是Global Dispatch Queue默认的优先级。如果想改变通过create生成Dispatch queue，通过dispatch_set_target_queue来指定与哪个Global Dispatch Queue的优先级一样：
    dispatch_queue_t queue = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);//串行队列
    dispatch_queue_t globalQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);//并发队列
    dispatch_set_target_queue(queue, globalQueueHigh);

代码中，指定了queue，与globalQueueHigh的优先级一样。

  1. dispatch_set_target_queue除了能用来设置队列的优先级之外，还能够创建队列的层次体系。当我们想让不同队列中的任务同步的执行时，我们可以创建一个串行队列，然后将这些队列的target指向新创建的队列，那么原本应该并行执行的多个队列在目标队列上开始同步执行，即同时只能执行一个任务。
dispatch_queue_t targetQueue = dispatch_queue_create("targetQueue", DISPATCH_QUEUE_SERIAL);//目标队列
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);//串行队列
    dispatch_queue_t queue2 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);//并发队列
    //设置参考
    dispatch_set_target_queue(queue1, targetQueue);
    dispatch_set_target_queue(queue2, targetQueue);

    dispatch_async(queue2, ^{
        NSLog(@"job3 in");
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"job3 out");
    });
    dispatch_async(queue2, ^{
        NSLog(@"job2 in");
        [NSThread sleepForTimeInterval:1.f];
        NSLog(@"job2 out");
    });
    dispatch_async(queue1, ^{
        NSLog(@"job1 in");
        [NSThread sleepForTimeInterval:3.f];
        NSLog(@"job1 out");
    });

输出结果：

2017-09-06 22:58:34.998 testMethodSwizzling[6748:2156619] job3 out
2017-09-06 22:58:34.998 testMethodSwizzling[6748:2156619] job2 in
2017-09-06 22:58:36.004 testMethodSwizzling[6748:2156619] job2 out
2017-09-06 22:58:36.005 testMethodSwizzling[6748:2156619] job1 in
2017-09-06 22:58:39.010 testMethodSwizzling[6748:2156619] job1 out

注意：Main Dispatch Queue/Global Dispatch Queue均不可用该函数指定。

4. dispatch_after

该函数并不是在指定的时候后执行任务，而是在指定的时间后追加任务到队列中。

    dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);
    dispatch_after(time, dispatch_get_main_queue(), ^{
        NSLog(@"3秒时间到");
    });
  • 第一个参数为dispatch_time_t类型。我们可以使用dispatch_time和dispatch_walltime函数，前者是用于计算相对时间，如距现在3秒；后者用于计算绝对时间，如2020年1月1日0时0分0秒。

5. Dispatch Group

在追加到Dispatch Queue中的多个处理结束后想执行结束处理，如果使用的是Serial Dispatch Queue，只需要在最后追加结束处理即可，但是如果使用的是Concurrent Dispatch Queue，就需要用到Dispatch Group。
无论向什么Dispatch Queue中追加处理，使用Dispatch Group都可以监视这些执行的结束。

  1. dispatch_group_notify
    使用如下：
    dispatch_queue_t concurrentDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, concurrentDispatchQueue, ^{
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"1");
    });
    dispatch_group_async(group, concurrentDispatchQueue, ^{
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"2");
    });
    dispatch_group_async(group, concurrentDispatchQueue, ^{
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"3");
    });
    
    //追加结束处理
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"done");
    });
    
    dispatch_group_async(group, concurrentDispatchQueue, ^{
        [NSThread sleepForTimeInterval:2.f];
        NSLog(@"4");
    });

2017-09-07 15:05:28.812 GCDTest[44028:4144855] 3
2017-09-07 15:05:28.812 GCDTest[44028:4144874] 2
2017-09-07 15:05:28.812 GCDTest[44028:4144856] 4
2017-09-07 15:05:28.812 GCDTest[44028:4144858] 1
2017-09-07 15:05:28.813 GCDTest[44028:4144767] done

在追加到Dispatch Group中的处理全部执行结束时，该代码中使用的dispatch_group_notify函数会将执行的Block追加到指定的Dispatch Queue中。可以看出即使在notify之后追加的，也一样，这一点与barrier要区分开来。

  1. dispatch_group_wait
    在Dispatch Group中也可以使用dispatch_group_wait函数，它会一直等待，直到指定的时间结束，或Dispatch Group中的处理全部执行完毕。
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

上边代码中，会一直等待到Dispatch Group中的处理执行结束，因为时间设置的是永远。“等待”的意思是该函数一直处于调用状态不返回，当前线程停止。

该函数的返回值：

  • 返回值等于0，表示Dispatch Group处理全部执行结束。
  • 返回值不等于0，表示是Dispatch Group没有执行结束，是由于时间到了导致的结束*。

我们可以使用dispatch_group_wait(group, DISPATCH_TIME_NOW);不用任何等待，即可判断Dispatch Group执行是否结束。

6. dispatch_barrier_async

场景：
在访问数据库或文件时，如前所述，使用Serial Dispatch Queue可避免数据竞争问题。
写入操作的确不可以与其他写入操作以及包含读取处理的其他处理并行执行，但是如果读取处理只是与读取处理并行执行，那么多个并行执行就不会发生问题。也就是说读取处理追加到Concurrent Dispatch Queue中，写入处理在任何一个读取处理没有执行的状态下，追加到Serial Dispatch Queue中即可（在写入处理结束之前，读取处理不可执行）。

dispatch_barrier_async函数与Concurrent Dispatch Queue一起使用：dispatch_barrier_async会等待之前追加到Concurrent Dispatch Queue中的执行全部执行完毕，然后再追加自己的处理到Concurrent Dispatch Queue中，等待dispatch_barrier_async追加的处理执行完毕后，再恢复Concurrent Dispatch Queue中的执行，之后的处理又开始并行执行。

代码如下：

    dispatch_queue_t concurrentDispatchQueue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read1");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read2");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read3");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read4");
    });
    dispatch_barrier_async(concurrentDispatchQueue, ^{
        NSLog(@"write-barrier");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read5");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read6");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read7");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"read8");
    });

输出结果：

2017-09-07 14:53:02.920 GCDTest[43953:4135868] read1
2017-09-07 14:53:02.920 GCDTest[43953:4135849] read2
2017-09-07 14:53:02.920 GCDTest[43953:4135869] read4
2017-09-07 14:53:02.920 GCDTest[43953:4135851] read3
2017-09-07 14:53:02.921 GCDTest[43953:4135851] write-barrier
2017-09-07 14:53:02.922 GCDTest[43953:4135869] read5
2017-09-07 14:53:02.922 GCDTest[43953:4135868] read7
2017-09-07 14:53:02.922 GCDTest[43953:4135851] read8
2017-09-07 14:53:02.922 GCDTest[43953:4135849] read6

使用Concurrent Dispatch Queue和dispatch_barrier_async函数可实现高效率的数据库访问和文件访问。

7. dispatch_(a)sync

  1. dispatch_async函数的async意味着非同步（asynchronous），就是将制定的Block非同步的追加到Dispatch Queue中，dispatch_async不做任何等待。
  2. dispatch_sync函数，将指定的Block“同步”的追加到指定Dispatch Queue中，该Block处理执行结束之前，该函数不会返回，即阻塞该线程。也可以说是简易版的dispatch_group_wait函数。
    正是因为dispatch_sync简单，所以也容易引起问题，死锁。
dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"死锁了呀");
    });

dispatch_sync会阻塞当前线程，直到后边的Block任务执行结束，而Block任务恰恰是在主线程中执行的被阻塞了，永远不会执行结束。

所以在使用dispatch_sync时一定要深思熟虑，稍有不慎就会导致程序死锁。

  1. dispatch_barrier_async和dispatch_barrier_sync的区别，为了更直观，我们来看一段代码：
dispatch_queue_t concurrentDispatchQueue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"1");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"2");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"3");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"4");
    });
    dispatch_barrier_async(concurrentDispatchQueue, ^{
        NSLog(@"barrier");
    });
    NSLog(@"aaaaa");
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"5");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"6");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"7");
    });
    dispatch_async(concurrentDispatchQueue, ^{
        NSLog(@"8");
    });

dispatch_barrier_async和dispatch_barrier_sync

  • 相同点：都是等待barrier之前的任务都执行完，再执行自己追加的任务，都是等待自己追加的任务结束之后，再执行barrier之后追加的任务。
  • 不同点：async在追加了自己的任务之后马上会执行之后的追加任务的代码，也就是代码中的“aaaa”会紧接着打印出来；
    而sync在追加了自己的任务之后，会等待在那里，直到自己追加的任务结束后再，执行后边的追加代码，所以“aaaa”一定会在“barrier”之后打印出来。我个人感觉它们在使用的时候，对于concurrentDispatchQueue内的处理没有影响，只会因为阻塞了当前线程而对队列外的其他处理造成影响。

8. dispatch_apply

  1. dispatch_apply函数是dispatch_sync和Dispatch Group的关联API。该函数按指定的次数，将指定Block追加到指定的Dispatch Queue中，并等待任务执行结束。
    dispatch_queue_t queue =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_apply(5, queue, ^(size_t index) {
        NSLog(@"%zu",index);
    });
    NSLog(@"done");

输出：

2017-09-07 16:46:00.556 GCDTest[44379:4211879] 1
2017-09-07 16:46:00.556 GCDTest[44379:4211881] 2
2017-09-07 16:46:00.555 GCDTest[44379:4211742] 0
2017-09-07 16:46:00.556 GCDTest[44379:4211864] 3
2017-09-07 16:46:00.556 GCDTest[44379:4211879] 4
2017-09-07 16:46:00.556 GCDTest[44379:4211742] done

可以看出，dispatch_apply会阻塞直到所有任务都完成。

  1. 我们看到dispatch_apply和dispatch_sync一样都会等待处理执行结束，这样总是不好的，推荐在dispatch_async函数中非同步的执行dispatch_apply。
dispatch_queue_t queue =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(queue, ^{
        dispatch_apply(5, queue, ^(size_t index) {
            NSLog(@"%zu:do something",index);
        });
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"更新ui");
        });
    });

9. dispatch_suspend/dispatch_resume

  • 使用dispatch_suspend函数挂起指定的Dispatch Queue
  • 使用dispatch_resume函数恢复指定的Dispatch Queue

这两个函数对已经执行的处理没有影响。挂起后，Dispatch Queue中尚未执行的处理在此之后停止执行，而恢复则使这些处理能够继续执行。

10. Dispatch Semaphore

当并行执行的处理更新数据时，会产生数据不一致的情况，有时应用程序还会异常结束。虽然使用Serial Dispatch Queue和dispatch_barrier_async函数可以避免这类问题，但有必要进行更细粒度的排他控制。
先看一段代码：

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSMutableArray *array = [[NSMutableArray alloc] init];
    
    for (int i=0; i<5000; i++) {
        dispatch_async(queue, ^{
            [array addObject:@(i)];
        });
    }

这一段代码，使用Global Dispatch Queue更新，由于内存错误很容易导致程序异常结束。此时应使用Dispatch Semaphore。
那么，什么是Dispatch Semaphore？
Dispatch Semaphore是持有计数的信号。整个思路是，计数为0时等待，计数为1或大于1时，减去1停止等待，开始执行处理，处理结束时将计数加1。

  1. dispatch_semaphore_create
    dispatch_semaphore_t semephore = dispatch_semaphore_create(1);
    通过该函数生成Dispatch Semaphore。
    参数标识计数的初始值。
  2. dispatch_semaphore_wait
    dispatch_semaphore_wait(semephore, DISPATCH_TIME_FOREVER);
    该函数会一直等待，直到Semaphore的计数值大于等于1，或到达设置的时间。如果semephore计数值大于等于1，对计数值减1，并且该函数返回。该函数的返回值与dispatch_group_wait类似，0表示由于计数大于等于1导致的返回，非0表示时间到了导致的返回。
  3. dispatch_semaphore_signal
    dispatch_semaphore_signal(semephore);
    通过该函数将semephore的计数值加1.
    完整的代码为：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSMutableArray *array = [[NSMutableArray alloc] init];
    dispatch_semaphore_t semephore = dispatch_semaphore_create(1);
    
    for (int i=0; i<5000; i++) {
        dispatch_async(queue, ^{
            dispatch_semaphore_wait(semephore, DISPATCH_TIME_FOREVER);
            [array addObject:@(i)];
            dispatch_semaphore_signal(semephore);
        });
    }

在没有Serial Dispatch Queue和dispatch_barrier_async函数那么大粒度且一部分处理需要进行排他控制的情况下，Dispatch Semaphore便可发挥威力。

11. dispatch_once

dispatch_once函数是保证在应用程序中只执行一次指定处理的API。

static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        
    });

即使在多线程环境下，也可保证百分百安全。

12. Dispatch I/O

在读取较大文件时，将文件分成合适的大小并使用Global Dispatch Queue并列读取，会比一般的读取速度快不少。
能实现这一功能的就是Dispatch I/O和Dispatch Data了。
分割读取的数据通过使用Dispatch Data可更为简单的进行结合和分割。

13. 为什么废弃dispatch_get_current_queue

  1. 该方法用于获取当前队列，iOS6.0已废弃。为什么呢？
    我们在使用dispatch_sync时一不小心就会导致死锁：
dispatch_sync(syncQueue, ^{
        NSLog(@"若当前队列就是串行syncQueue，死锁了呀");
    });

如果当前队列就是串行syncQueue，就会导致死锁，所以我们经常会通过dispatch_get_current_queue来判断目标队列是不是当前队列。
这种做法可以处理简单的情况，但是仍有死锁的危险，比如，有两个串行队列：

dispatch_queue_t queueA = dispatch_queue_create("queueA", DISPATCH_QUEUE_SERIAL);//串行队列
    dispatch_queue_t queueB = dispatch_queue_create("queueB", DISPATCH_QUEUE_SERIAL);//串行队列
    dispatch_sync(queueA, ^{
        dispatch_sync(queueB, ^{
            if (dispatch_get_current_queue()!=queueA) {
                dispatch_sync(queueA, ^{
                    NSLog(@"dosomething");
                });
            }
            else
            {
                NSLog(@"dosomething");
            }
            
        });
    });

虽然判断了当前队列不是queueA，但是依然死锁了。
因为最外层的已经阻塞queueA，直到里边的内容执行完毕，而最里边的内容是在queueA上执行的，A已经被阻塞了，又不可能执行完毕，所以导致了死锁。
这么看来使用dispatch_get_current_queue，仍然会有导致死锁的危险。

  1. 那我们使用什么方式来解决这种情况呢？
    上边的例子显得有点做作，那么我们找个正常点的例子：两个串行队列A、B，其中A是B的目标队列，这样队列之间会形成层级体系，B中的任务稍候都会在A中一次执行，于是排在AB中的任务都是在A中串行执行，这时如果在队列B中的块中，判断当前队列不是A那么就认为可以在队列A上执行同步派发操作，实际上会导致死锁。
    解决方案：队列特有数据
    通过dispatch_queue_set_specific可以把任意数据以键值对的形式关联到队列指定队列里。在需要判断当前队列是不是目标队列的时候，然后通过dispatch_get_specific获取，如果能取到说明当前队列就是目标队列，如果没有就说明不是。
dispatch_queue_t queueA = dispatch_queue_create("com.xxx.xxx", NULL);
    static int kQueueSpecificKey = 111111;
    CFStringRef value = CFSTR("queueAValue");
    //给queueA设置队列特有数据
    dispatch_queue_set_specific(queueA, &kQueueSpecificKey, (void *)value, (dispatch_function_t)CFRelease);
    
    //需要判断queueA是不是当前队列的时候，只需要获取队列特有数据，看能否取到之前设置的值即可
    CFStringRef retrievedValue = dispatch_get_specific(&kQueueSpecificKey);
    if (retrievedValue) {
        //当前队列就是queueA，因为能取到队列特有数据
    }
    else
    {
        //当前队列不是queueA，因为没有取到队列特有数据
    }

二、典型例子

只要是调用dispatch_sync同步执行任务，不管是提交并发队列还是串行队列，都是在当前线程上执行。

1.
- (void)viewDidLoad {
    dispatch_sync(dispatch_get_main_queue(), ^{
        [self dosomething];
    });
}

这种情况会导致死锁，但是一定要知道，是由队列引起的循环等待，而不是由线程引起的

iOS-GCD_第1张图片
死锁原因
2.
- (void)viewDidLoad {
    dispatch_sync(serial_queue, ^{
        [self dosomething];
    });
}

这种情况不会引起死锁。


iOS-GCD_第2张图片
屏幕快照 2018-04-15 下午1.35.08.png

你可能感兴趣的:(iOS-GCD)

  • iOS-GCD原理分析（一） 似水流年_9ebe
    前言GCD在我们的实际开发中，用到非常之我，那么它的原理是怎么样的，我们来分析下。GCD概念全称是GrandCentralDispatch纯C语⾔，提供了⾮常多强⼤的函数GCD的优势：GCD是苹果公司为多核的并⾏运算提出的解决⽅案GCD会⾃动利⽤更多的CPU内核（⽐如双核、四核）GCD会⾃动管理线程的⽣命周期（创建线程、调度任-务、销毁线程）程序员只需要告诉GCD想要执⾏什么任务，不需要编-写任何
  • （链接）GCD 考拉小姐_zzzZZZ
    一通过GCD中的dispatch_barrier_(a)sync所谓等待的理解二iOS-GCD之初，disPatch队列和线程的关系三GCD中的dispatch_after使用说明
  • iOS-GCD a_超
    GCD是一种易用、高效的多线程技术，可代替NSThread和performSelector使用，其性能高于NSThread。创建/获取GCD可创建有序执行的线程（串行线程）和无序线程（并行）两种。全局线程是所有应用程序共用的并行线程，实效性相对较差。串行线程会等待前一个线程执行完成再执行另一个线程。dispatch_queue_tqueue=dispatch_queue_create("MY_TH
  • iOS-GCD的基本使用和死锁问题 长衣貌
    1./异步函数加并发队列/**异步函数+并发队列组合会开启多条线程,(异步函数具备开线程的能力,但不是每次都必须开新的线程)队列中的任务是异步执行的(无序的,一起执行)注意:GCD中并发队列开多少条线程是不受控制的,系统会根据CPU使用情况自行决定开多少条线程*/-(void)asyncConcurrent{/**1./创建一个新的队列第一个参数:标签(C语言的字符串,不能加@符)第二个参数:创建
  • iOS-GCD定时器的使用 我是何先生
    在iOS开发的过程中定时器的使用比较频繁的,比较常见的场景是验证码的发送,或者是倒计时的展示.一般的需求我们直接使用NSTimer就能完成。但是NSTimer的坑也是比较多的，比如在UITableview的时候，需要把NSTimer添加到主循环，并且设置为NSRunLoopCommonModes。但是今天要记录的是:GCD定时器先直接贴代码File:GCDCountDown.h@interface
  • ios-GCD 核心 Clark_new
    GCD,全称是GrandCentralDispatch,纯C语言，提供了非常多强大的函数.是苹果公司为多核的并行运算提出的解决方案,会自动利用更多的CPU内核（比如双核、四核),会自动管理线程的生命周期（创建线程、调度任务、销毁线程）,程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码.核心概念1.将任务添加到队列，并且指定执行任务的函数2.任务使用block封装任务的block没
  • IOS－GCD一种死锁情况分析 MikeZhangpy
    问题分析：主线程执行下面方法，这种情况为什么会死锁？-(void)viewDidLoad{dispatch_sync(dispatch_get_main_queue(),block());}1.理解dispatch_syncdispatch_async的工作流程dispatch_sync(queue,block)做了两件事：1）将block添加到queue队列中2）阻塞调用线程，等待block（）
  • iOS-GCD死锁 精神病患者link常
    NSLog(@"1");//任务1dispatch_sync(dispatch_get_main_queue(),^{NSLog(@"2");//任务2});所谓死锁，通常指有两个线程A和B都卡住了，A在等B,B在等A,相互等待对方完成某些操作。A不能完成是因为它在等待B完成。但B也不能完成，因为它在等待A完成。于是大家都完不成，就导致了死锁（DeadLock）。死锁原因dispatch_sync
  • iOS-GCD队列组的使用 长衣貌
    -(void)group1{//获取全局并发队列dispatch_queue_tqueue=dispatch_get_global_queue(0,0);//创建一个并发队列dispatch_queue_tqueue1=dispatch_queue_create("peiDuo",DISPATCH_QUEUE_CONCURRENT);//创建队列组dispatch_group_tgroup=dis
  • iOS-GCD的串行队列和并行队列的任务及实现 Cui_Ankly 多线程
    •什么是GCDGCD全称是GrandCentralDispatch,纯C语言的，提供了非常多强大的函数•GCD的优势1,GCD是苹果公司为多核的并行运算提出的解决方案2,GCD会自动利用更多的CPU内核（比如双核、四核）3,GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）4,程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码•GCD的核心:将任务添加到队列•任务：执行
  • IOS-GCD中的Timer a330416020 iOS
    -(IBAction)gcdResourceTestBtnPressed:(id)sender{///初始化一个gcd队列.dispatch_queue_ttimerQueue=dispatch_queue_create("timerQueue",0);///创建gcdtimer._timerSource=dispatch_source_create(DISPATCH_SOURCE_TYPE_TI
  • ios-GCD和NSOperation的区别 rv0p111 ios-开发
    GCD相比于NSOperation中有调度组，有延迟函数，如果我们想延迟的在子线程上做一些事情，我们只需要把dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(3*NSEC_PER_SEC)),dispatch_get_main_queue(),^{NSLog(@"kkk");});把这个主队列改成全局并发队列或者并发队列或者串行队列都
  • IOS-GCD多线程 hz951290428 IOS
    同步&异步：区别在于会不会阻塞线程：同步会等待当前任务结束再去执行下一个任务；异步是同时进行执行任务。串行&并行：dispatch_get_main_queue-->主线程的队列dispatch_get_global_queue-->全局线程的队列(全局并发的)简单的例子：dispatch_async(dispatch_get_global_queue(0,0),^{NSLog(@"TaskThr
  • IOS-GCD实现单例模式 文学振噢
    单粒是一种设计模式，目的是禁止多次访问内存在程序运行中无论创建多少个对象都只有一个实例（1个类1个对象），只共享一个资源既然是多次禁止访问内存，并且是只有一个实例，那我们可以从alloc着手同时因为GCD的dispatch_once_t是在整个程序中只执行一次的staticdispatch_once_tonceToken;dispatch_once(&onceToken,^{});那么如何写单例呢
  • iOS-GCD实现定时器 hyeeyh
    今天要和大家分享的是利用GCD实现定时器，一向少废话的我，就不和大家墨迹了，直接上代码，我这里以实现验证码按钮以例：//首先是验证码间隔时间__blockinttimeout=59;//建立一个全局队列dispatch_queue_tqueue=dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);//创建一个定时器事件源disp
  • iOS-GCD多线程的基本使用 造夢
    如果你要使用多线程，在iOS中，使用GCD这种方式简直就是烂大街了。所以必须学习，不然你怎么看得懂别人的代码惹。以下只是告诉你怎么使用GCD开启多线程，想要理论的请百度GCD（哇，好多）GCD中有2个用来执行任务的函数（！=。=C语言的知识惹）dispatch_sync:同步执行，不开新线程dispatch_async:异步执行，开启新线程同时还要理解另外两个概念：串行和并发队列（执行任务的方式）
  • iOS-GCD之初，disPatch队列和线程的关系 SOI
    关于GCD的最最基本的知识，往往很多初学者都被忽略。理解上造成了偏差，而不注重去实践，所有我们需要认真的总结一下。dispatch_asyn和dispatch_sync添加任务到dispatch队列时，是否创建线程呢，那么创建线程是创建一个呢还是多个呢，如果你自己能直接分的清楚就不必看我下文的实践代码了，下文的代码做了详细的说明，不仅仅是代码，也包含了总结，如果你想实践的话，也可以跟着实践一遍哦，
  • iOS-GCD学习总结 SuperDawn_0828
    1、前言GCD的学习中一定要理解任务，同步、异步，串行、并发的概念，以及他们之间相互结合运行的效果。2、GCD的基本概念任务：任务就是将要在线程中执行的代码，用block快封装好，添加到指定的执行方式，等待CPU从队列中取出任务放到对应的线程中执行。同步：任务一个接着一个的执行，前一个执行完，后一个才开始执行；不开启新的线程。异步：任务同一时间可以一起执行；开启多个新的线程。队列：装在线程任务的队
  • iOS-GCD信号量实现最大并发 _清墨
    1.实现最大并发数，在iOS里，最容易使用的是NSOperationQueue，如下NSOperationQueue*queue=[[NSOperationQueuealloc]init];queue.maxConcurrentOperationCount=2;NSOperationQueue中，已经考虑到了最大并发数的问题，并提供了maxConcurrentOperationCount属性设置最
  • OC -> GCD KongGG
    iOS-GCD概念bigGCD(GrandCentralDispatch):伟大的的中枢调节器;GCD是苹果公司开发的一个创建子线程的一个方法，主要为多核的并行开发运算提出解决方案，利用GCD可以是的CPU的内核运用的更加充分，同时GCD也会自动管理线程中的生命周期。small1.队列：队列是一种线性表，队列的上下都是开口的与栈相反，队列中遵循的原则是FIFO即为先进先出，队列是在表尾进行添加操作
  • iOS-GCD从认识到高深莫测 树下敲代码的超人
    技术文章/超人GCD介绍GrandCentralDispatch(GCD)是Apple开发的一个多核编程的较新的解决方法,可译为“牛逼的中枢调度器”纯C语言，提供了非常多强大的函数。它主要用于优化应用程序以支持多核处理器以及其他对称处理系统，GCD会自动利用更多的CPU内核（比如双核、四核）。它是一个在线程池模式的基础上执行的并行任务。在MacOSX10.6雪豹中首次推出，也可在IOS4及以上版本
  • iOS-GCD中的队列及实现 xiaoyuyang612
    基本概念进程：进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，在iOS系统中，开启一个应用就打开了一个进程。线程：线程（Thread）是进程中的一个实体，程序执行的基本单元。在iOS系统中，一个进程包含一个主线程，它的主要任务是处理UI事件，显示和刷新UI。同步：在当前线程依次执行，不开启新的线程。异步：多个任务情况下，一个任务A正在执行，同时可以执行另一个任务B。任务B不用
  • ios-GCD基础篇同步、异步，并发、并行的理解 哼宾克斯的酒的梅丽
    一、关于GCDGCD全称是GrandCentralDispatch，是苹果公司为多核的并行运算提出的解决方案，GCD会自动利用更多的CPU内核（比如双核、四核），GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）二、关于同步、异步、并发、串行同步和异步决定了要不要开启新的线程同步：在当前线程中执行任务，不具备开启新线程的能力异步：在新的线程中执行任务，具备开启新线程的能力并发和串行决定
  • iOS-GCD doudo
    一、GCD的API1.Dispatchqueue在执行处理时存在两种Dispatchqueue：等待现在执行中任务结束的SerialDispatchqueue不等待现在执行中任务结束的ConcurrentDispatchqueueSerialDispatchqueue：一个SerialDispatchqueue只生成并使用一个线程，顺序执行。ConcurrentDispatchqueue：使用多个
  • iOS-GCD多线程死锁案例 爱恨的潮汐
    一、死锁场景:主线程调用主线程。-(void)deadLockCase1{NSLog(@"1");//任务1dispatch_sync(dispatch_get_main_queue(),^{NSLog(@"2");//任务2});NSLog(@"3");//任务3}控制台输出：1，后面就崩溃了。原因:从控制台输出可以看出，任务2和任务3没有执行，此时已经死锁了。因为dispatch_sync是同
  • iOS-GCD使用详解及实例解析
    iOS-GCD使用详解前言对初学者来说，GCD似乎是一道迈不过去的坎，很多人在同步、异步、串行、并行和死锁这几个名词的漩涡中渐渐放弃治疗。本文将使用图文表并茂的方式给大家形象地解释其中的原理和规律。线程、任务和队列的概念异步、同步&并行、串行的特点一条重要的准则一般来说，我们使用GCD的最大目的是在新的线程中同时执行多个任务，这意味着我们需要两项条件：能开启新的线程任务可以同时执行结合以上两个条件
  • iOS-GCD详解及简单使用
    iOS-GCD介绍在开发过程中，我们有时会希望把一些操作封装起来延迟一段时间后再执行。iOS开发中，有两种常用的方法可以实现延迟执行，一种是使用GCD，另外一种是使用NSRunLoop类中提供的方法。前言对初学者来说，GCD似乎是一道迈不过去的坎，很多人在同步、异步、串行、并行和死锁这几个名词的漩涡中渐渐放弃治疗。本文将使用图文表并茂的方式给大家形象地解释其中的原理和规律。线程、任务和队列的概念异
  • iOS-GCD使用详解 传说中的汽水枪
    前前言本文绝大部分内容来自https://www.cnblogs.com/allencelee/p/6023213.html此文章是学习此文章后的新的相关结果.[]是修改/添加的内容代码和打印结果都改了一下.Mac环境:macOSHighSierra10.13.4Xcode9.2手机:iOS11.1.2iPhone6s前言对初学者来说，GCD似乎是一道迈不过去的坎，很多人在同步、异步、串行、并行和
  • iOS-GCD学习之同步异步线程去执行串行操作 Anber_zhi IOS进阶
    今天碰到一个需求，在网上找了一下资料，不得不感叹GCD之强大实用。队列：串行队列，并行队列，全局队列，主队列//串行队列同步执行任务会在当前线程内执行#不一定是主线程//异步的方式执行串行队列会创建一个新的线程来执行任务//串行的队列都是按照顺序来执行。就是任务1->任务2-》任务3[objc]viewplaincopy//串行队列同步执行任务会在当前线程内执行//所以打印的会是当前线程的编号不一
  • iOS多线程实现方案之 -- GCD devZhang
    昨天通过多线程实现方案之--NSThread说了关于NSThread多线程的一些知识点和用法,其实之前我也写过一篇关于GCD的分享-iOS-GCD编程,使用的GCD是基于封装过的,今天是深入学习总结GCD相关知识以及GCD在实际开发中的使用什么是GCD全称是GrandCentralDispatch纯C语言,提供了非常强大的函数GCD的优势GCD是苹果公司为多核的并发运算提出的解决方案GCD会自动利
  • sql统计相同项个数并按名次显示 朱辉辉33 javaoracle
    现在有如下这样一个表： A表 ID Name time ------------------------------ 0001 aaa 2006-11-18 0002 ccc 2006-11-18 0003 eee 2006-11-18 0004 aaa 2006-11-18 0005 eee 2006-11-18 0004 aaa 2006-11-18 0002 ccc 20
  • Android+Jquery Mobile学习系列-目录 白糖_ JQuery Mobile
    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。   从现在起，往后一段时间，我打算
  • 如何给线程池命名 daysinsun 线程池
            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下：     public class Named
  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the 周凡杨 html解析errorreadyState
      错误： IE 中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"     现象： 同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
  • java上传 g21121 java
    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 下面是servlet的代码： //定义一个磁盘文件工厂 DiskFileItemFactory fact
  • SpringMVC配置学习 510888780 springmvc
    spring MVC配置详解 现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
  • spring mvc-jfreeChart 柱图(1) 布衣凌宇 jfreechart
    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 第二步：配置web.xml; web.xml代码如下 <servlet>     <servlet-name>jfreechart</servlet-nam
  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
  • java 线程池使用 Runnable&Callable&Future antlove javathreadRunnablecallablefuture
    1. 创建线程池 ExecutorService executorService = Executors.newCachedThreadPool();   2. 执行一次线程，调用Runnable接口实现 Future<?> future = executorService.submit(new DefaultRunnable()); System.out.prin
  • XML语法元素结构的总结 百合不是茶 xml树结构
    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
  • 改变eclipse编码格式 bijian1013 eclipse编码格式
    1.改变整个工作空间的编码格式         改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。         Eclipse->window->preferences->General->workspace-
  • javascript中return的设计缺陷 bijian1013 JavaScriptAngularJS
    代码1： <script> var gisService = (function(window) { return { name:function () { alert(1); } }; })(this); gisService.name(); &l
  • 【持久化框架MyBatis3八】Spring集成MyBatis3 bit1129 Mybatis3
    pom.xml配置 Maven的pom中主要包括： MyBatis MyBatis-Spring Spring MySQL-Connector-Java Druid applicationContext.xml配置   <?xml version="1.0" encoding="UTF-8"?> &
  • java web项目启动时自动加载自定义properties文件 bitray javaWeb监听器相对路径
    创建一个类 public class ContextInitListener implements ServletContextListener 使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 <listener> <des
  • 用nginx区分文件大小做出不同响应 ronin47
    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大 bylijinnan java
    package com.ljn.base; import java.util.Arrays; import java.util.Random; public class ContinuousPoker { /** * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。 * 2-10为数字本身，A为1，J为1
  • 翟鸿燊老师语录 ccii 翟鸿燊
    一、国学应用智慧TAT之亮剑精神A 1. 角色就是人格     就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。     还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
  • [光速与宇宙]进行光速飞行的一些问题 comsci 问题
         在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家     仅仅是猜想。。。未经官方证实      1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
  • oracle undo解析 cwqcwqmax9 oracle
    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 Undo是干嘛用的？         &nb
  • java中各种集合的详细介绍 dashuaifu java集合
    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
  • 卸载windows服务的方法 dcj3sjt126com windowsservice
    卸载Windows服务的方法 在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist dcj3sjt126com iosxcode
        http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html Excerpt: You are getting this warning because you probably added your Info.plist file to your Copy Bundle
  • 2014之C++学习笔记（一） Etwo C++EtwoEtwoiterator迭代器
            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
  • js跨越获取数据问题记录 haifengwuch jsonpjsonAjax
    js的跨越问题，普通的ajax无法获取服务器返回的值。   第一种解决方案，通过getson，后台配合方式，实现。 Java后台代码： protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String ca
  • 蓝色jQuery导航条 ini JavaScripthtmljqueryWebhtml5
    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
  • linux部署jdk,tomcat,mysql kerryg jdktomcatlinuxmysql
    1、安装java环境jdk:     一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。    1.1）、卸载：      （rpm -qa :查询已经安装哪些软件包；        rmp -q 软件包：查询指定包是否已
  • DOMContentLoaded VS onload VS onreadystatechange mutongwu jqueryjs
    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 2. onload是最早支持的事件，要求所有资源加载完毕触发。 3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
  • sql批量插入数据 qifeifei 批量插入
    hi，   自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。    WITH tempT AS ( SELECT item_id AS combo_id, item_id, now() AS create_date FROM a
  • log4j打印日志文件 如何实现相对路径到 项目工程下 thinkfreer Weblog4j应用服务器日志
    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 需求： 用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
  • linux下mysql-5.6.23.tar.gz安装与配置 笑我痴狂 mysqllinuxunix
    1.卸载系统默认的mysql [root@localhost ~]# rpm -qa | grep mysql mysql-libs-5.1.66-2.el6_3.x86_64 mysql-devel-5.1.66-2.el6_3.x86_64 mysql-5.1.66-2.el6_3.x86_64 [root@localhost ~]# rpm -e mysql-libs-5.1
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他