dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {

            // 耗时的操作

            dispatch_async(dispatch_get_main_queue(), {

                // 更新界面

                })

            })

// 根据url获取UIImage

- (UIImage *)imageWithURLString:(NSString *)urlString {

    NSURL *url = [NSURL URLWithString:urlString];

    NSData *data = [NSData dataWithContentsOfURL:url];

    // 这里并没有自动释放UIImage对象

    return [[UIImage alloc] initWithData:data];

}  

- (void)downloadImages {

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  

    // 异步下载图片

    dispatch_async(queue, ^{

        // 创建一个组

        dispatch_group_t group = dispatch_group_create();  

        __block UIImage *image1 = nil;

        __block UIImage *image2 = nil;  

        // 关联一个任务到group

        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

            // 下载第一张图片

            NSString *url1 = @"http://car0.autoimg.cn/upload/spec/9579/u_20120110174805627264.jpg";

            image1 = [self imageWithURLString:url1];

        });  

        // 关联一个任务到group

        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

            // 下载第二张图片

            NSString *url2 = @"http://hiphotos.baidu.com/lvpics/pic/item/3a86813d1fa41768bba16746.jpg";

            image2 = [self imageWithURLString:url2];

        });  

        // 等待组中的任务执行完毕,回到主线程执行block回调

        dispatch_group_notify(group, dispatch_get_main_queue(), ^{

            self.imageView1.image = image1;

            self.imageView2.image = image2;  

            // 在这里释放图片资源

            [image1 release];

            [image2 release];

        });  

        // 释放group

        dispatch_release(group);

    });

}  

        NSLog("begin");

        let queue = dispatch_queue_create("gcdtest.rongfzh.yc", DISPATCH_QUEUE_CONCURRENT)

        dispatch_async(queue, {

            NSThread.sleepForTimeInterval(2)

            NSLog("dispatch_async1");

            }

        );

        dispatch_async(queue, {

            NSThread.sleepForTimeInterval(4)

            NSLog("dispatch_async2");

            }

        );

        dispatch_barrier_async(queue, {

            NSLog("dispatch_barrier_async");

            NSThread.sleepForTimeInterval(4)

            }

        );

        dispatch_async(queue, {

            NSThread.sleepForTimeInterval(1)

            NSLog("dispatch_async3");

            }

        );

        dispatch_async(queue, {

            NSThread.sleepForTimeInterval(1)

            NSLog("dispatch_async4");

            }

        );

 //let delayInSeconds:Int64 = 1000，000，000 * 2  // Int64(2 * NSEC_PER_SEC)

 let time = dispatch_time(DISPATCH_TIME_NOW, Int64(2 * NSEC_PER_SEC))

 dispatch_after(time, dispatch_get_main_queue()){

      //...

} 

+ (instancetype)sharedInstance {

　　static id sharedInstance;

　　static dispatch_once_t onceToken;

　　dispatch_once(&onceToken, ^{

　　　　sharedInstance = [self new];

　　});

　　return sharedInstance;

} 

let queue = dispatch_queue_create("gcdtest.rongfzh.yc", DISPATCH_QUEUE_CONCURRENT)

dispatch_apply(30, queue, {print("|*\($0)*|")})

let queue = dispatch_queue_create("gcdtest.rongfzh.yc", DISPATCH_QUEUE_SERIAL)

dispatch_apply(30, queue, {print("|*\($0)*|")})

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// Create dispatch_semaphore

// semaphore value初始化为1

/ 保证可访问NSMutableArray类对象的线程同时只有一个

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

NSMutableArray *array = [[NSMutableArray alloc] init];

for (int i = 0; i < 100000; i++) {

dispatch_async(queue, ^{

 // Waiting for dispatch semaphore, 直到semaphore值达到大于等于1

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

// 由于Dispatch semaphore的计数值达到大于等于1

// 所以将Dispatch semaphore的计数值减1

// dispatch_semaphore_wait函数执行返回

// 即执行到此时的Dispatch semaphore计数值恒为0

// 由于可访问NSMutableArray类对象的线程只有一个

// 因此可安全进行更新

[array addObject:[NSNumber numberWithInt:i]];

// 排他控制处理结束

// 所以通过dispatch_semaphore_signal函数

// 将Dispatch semaphore的计数值加1

// 如果有通过dispatch_semaphore_wait函数等待Dispatch semaphore的

// 计数值增加的线程，由最先等待的线程执行

dispatch_semaphore_signal(semaphore);

});

}

26 dispatch_release(semaphore);

// 并发读取文件原理

dispatch_async(queue, ^{/* 读取0-8191字节*/});

dispatch_async(queue, ^{/* 读取8192-16383字节*/});

dispatch_async(queue, ^{/* 读取163784-24575字节*/});

dispatch_async(queue, ^{/* 读取24576-32767字节*/});

dispatch_async(queue, ^{/* 读取32768-40959字节*/});

dispatch_async(queue, ^{/* 读取40960-49151字节*/});

dispatch_async(queue, ^{/* 读取49152-57343字节*/});

dispatch_async(queue, ^{/* 读取57344-65535字节*/});

// 实例代码如下

dispatch_queue_t pipe_q = dispatch_queue_create("PipQ", NULL);

dispatch_io_t pipe_channel = dispatch_io_create(DISPATCH_IO_STREAM, fd, pip_q, &(int err){

    close(fd);

});

*out_fd = dfpair[1];

// 设定函数一次读取的大小(分割大小）

dispatch_io_set_low_water(pipe_channel, SIZE_MAX);

dispatch_io_read(pipe_channel, 0, SIZE_MAX, pipe_q, ^{

    if (0 == err) {

        size_t len = dispatch_data_get_size(pipedata);

        if (len > 0) {

            const char *bytes = NULL;

            char *encoded;

            dispatch_data_t md = dispatch_data_create_map(pipedata, (const void **)&bytes, &len);

            encoded = asl_core_encode_buffer(bytes, len);

            asl_set((aslmsg)merged_msg, ASL_KEY_AUX_DATA, encoded);

            free(encoded);

            _asl_send_message(NULL, merged_msg, -1, NULL);

            _asl_msg_release(merged_msg);

            dispatch_release(md);

        }

    }

    if (done) {

        dispatch_semaphore_signal(sem);

        dispatch_release(pipe_channel);

        dispatch_release(pipe_q);

    }

});