GCD之各种派发
dispatch_apply的用法
并行模拟for循环，将指定的代码循环10次，一般会把这些代码附加到一个queue上，然后在 dispatch_apply里并行
dispatch_queue_t queue = dispatch_get_globel_queue(DISPATCH_QUEUE_PREORITY_DEFAULT,0)
dispatch_apply(10, queue, ^(size_t index){
NSLog("并行执行--%@",index);
});
dispatch_apply_f的用法
dispatch_apply 和 dispatch_apply_f 是同步函数,会阻塞当前线程直到所有循环迭代执行完成。当提交到并发queue时,循环迭代的执行顺序是不确定的
dispatch_after
延迟指定时间之后执行任务
dispatch_after(dispatch_time_t when, dispatch_queue_t queue, ^(void)block)
when：延迟执行时间 一般是一个这样的时间函数： dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC))
queue：队列 dispatch_get_main_queue()或者 dispatch_get_global_queue()
block：执行的任务
dispatch_once
dispatch_once(dispatch_once_t *predicate, ^(void)block)
predicate： 用来判断需要执行的任务是否执行完成
block ：需要执行的一次性任务
+ (instantClass *)sharedClient {
static instantClass *_sharedClient = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_sharedClient = [[instantClass alloc] init];
});
return _sharedClient;
}
dispatch_group
dispatch_grpup,把若干个任务放到一个dispatch group中
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PREORITY_DEFAULT,0);
dispatch_queue_group group = dispatch_group_craete();
dispatch_group_aysnc(group, queue,^{
//do some async work
});
dispatch_group_async 和 dispatch_async一样，会把任务放到queue中执行，只不过它比dispatch_async多了一步操作，就是把这个任务和group相关联，
把这些任务放到group之后，我们可以调用dispatch_group_wait来等待任务完成。若任务已经全部完成或者为空，直接返回，否则等待所有任务完成之后返回。注意返回之后任务清空。
dispatch_group_wait(group,DISPATCH_TIME_FORVER);
dispatch_release(group);
dispatch_semaphore信号量
GCD信号量机制
信号量就是一些有限可数的资源。比如打印机，假如系统有两台打印机。但同时又5个任务要使用打印机，那么只有2个任务能同时进行打印，剩下3个要等待着2个任务打印完。那么程序工作过程应该是：任务首先获取打印机资源（dispatch_semaphore_wait）,如果没有打印机可用了就要等待，直到其他任务用完这个打印机。当任务获取到打印机，就开始执行打印任务。任务用完打印机工作后，就必须把占用打印机释放（dispatch_semaphore_signal）,以便其他任务可以接着打印。
//创建资源的信号量，只创建一次，比如2台打印机，那么 RESOURCE_SIZE为2.
dispatch_semaphore_t sema = dispatch_semaphore_create(RESORCE_SIZE);
//如果任务使用一个资源时，使用前调用dispatch_semaphore_wait,用完后dispatch_semaphore_signal.
//下面的代码可能在多个线程中调用多次
dispathc_semaphore_wait(sema, DISPATCH_TIME_FORVER);
//do some work here , the work will use one resource.
dispatch_semaphore_signal(sema);
信号量必须在资源使用之前调用dispatch_semaphore_create创建，而且只创建一次，RESOURCE_SIZE是可用资源总数。使用资源时dispatch_semaphore_wait将资源的可用数减少一个，如果当前没有可用资源了，将会等待直到其他线程回收资源，即调用dispatch_semaphore_signal让可用资源增加。用完资源后调用dispatch_semaphore_signal回收可利用资源。资源可用数将增加一个。
如果是生产者-消费者模型的花，RESOURCE_SIZE可能最初为0，那么生产者调用dispatch_semaphore_signal来生产一个单位的资源，消费者调用dispatch_semaphore_wait来消费（减少）一个单位的资源。当资源不足时，消费者会一直等待到资源数大于0，即生产者生成新的资源。
dispatch source（定时器，进程，文件，Mach port相关）
dispatch source 是GCD中监听一些系统事件的，有个Dispatch对象，它包括定时器、文件监听、进程监听，Mach port 监听等类型。
可以通过dispatch_source_create创建一个Dispatch Source:
dispatch_source_t dispatch_source_cerate(
dispatch_source_type_t type,
uintptr_t handle,
unsigned long mask,
dispatch_queue_t queue);
这里可以指定Dispatch Source 的类型， type可以为文件读或写、进程监听等。handel为监听对象的句柄，如果是文件就是文件描述符，如果是进程就是进程ID, mask用来指定一些想要监听的时间，它的意义取决于type.queue指定事件处理的任务队列。
创建好dispatch source 之后，我们要为 dispatch source 设置一个事件处理模块。可以用dispatch_source_set_event_handler或者dispatch_source_set_event_hander_f来设置：
void dispatch_source_source_set_event_handler(
dispatch_source_t source,
dispatch_block_t handler
)
设置好Dispatch Source 后就可以调用dispatch_resume来启动监听。
如果相应的事件发生就会触发事件处理模块。
同时我么也可以设置一个取消处理模块：
dispatch_source_set_cancel_handler(mySource, ^{
//Close a file descriptor opened earlier.
close(fd);
});
取消处理模块会在Dispatch Source 取消时调用。
定时器
定时器 Dispatch Source 可以每隔一个固定的时间处理一下任务。
dispatch_source_t CreateDispatchTimer(uint64_t interval, uint64 leeway, dispatch_queue_t queue, dispatch_block_t block){
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0 , queue);
if(timer){
dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), interval, leeway);
dispatch_source_set_event_handler(timer, block);
dispatch_resume(timer);
}
return timer;
}
void MyCreateTimer(){
dispatch_source_t aTimer = CreateDispatchTimer(30ull * NSEC_PER_SEC,1ull * NSEC_PER_SEC, dispatch_get_main_queue(), ^{ MyPeriodicTask();})
//Store it somewhere for later use
if(aTimer){
MyStoreTimer(aTimer);
}
}
监听文件事件
监听文件事件分好几个类型，有读、写、属性的监听
读取文件
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, fd ，0， queue);
dispatch_source_set_event_handler(source, ^{
//get some data form the source variable, which is captured
//form the parent context.
size_t estimated = dispatch_source_get_data(source);
//continue reading the descriptor
});
dispatch_resume(source);
写文件
dispatch_source_t writeSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE, fd， 0 ， queue);
if(!writeSource){
close(fd);
return NULL;
}
dispatch_source_set_event_handeler(writeSource, ^{
size_t bufferSize = MyGetDataSize();
void *buffer = malloc(bufferSize);
size_t actual = MyGetData(buffer, bufferSize);
write(fd, buffer, actual);
free(buffer);
//cancel and release the dispatch source when done.
dispatch_source_cancel(writeSource);
});
监听文件属性
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_VNODE, fd, DISPATCH_VNODE_RENAME, QUEUE);
if(source){
//copy the filename for ater use
int length = strlen(filename);
char * newString = (char*) malloc(length + 1);
new String = strcpy(newString , filename);
dispatch_set_context(source, newString);
//install the event handler to process the name change dispatch_source_set_event_handeler(source, ^{
const char* oldFilename = (char*)dispatch_get_context(source);
MyUpdateFileName(oldFilename, fd);
});
//Install a cancellation handler to free the descriptor
//and the stored string
dispatch_source_set_cancel_hander(source, ^{
char *fileStr = (char*)dispatch_get_context(source);
free(fileStr);
close(fd);
});
// Start processing events.
dispatch_resume(source);
}else{
close(fd);
}
监听进程事件
DISPATCH_PROC_EXIT是一个监听进程退出的类型。
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_PROC, parentPID, DISPATCH_PROC_EXIT, queue);
if(source){
dispatch_source_set_event_handler(source, ^{
MySetAppExitFlag();
dispatch_source_cancel(source);
dispatch_rellease(source);
});
dispach_resume(source);
}
监听中断信号
dispatch_source_t source = dispatch_create_source(DISPATCH_SOURCE_TYPE_SIGNAL, SIGHUP, 0, queue);
if(source){
dispatch_source_set_event_handler(source, ^{
MyProcessSIGHUP();
});
//Start processing signals
dispatch_requme(source);
}
