iOS开发进阶：多线程

// 同步 + 串行
dispatch_sync(serial_queue, ^{
//任务
});
// 异步 + 串行
dispatch_async(serial_queue, ^{
//任务
});
// 同步 + 并发
dispatch_sync(concurrent_queue, ^{
//任务
});
// 异步 + 并发
dispatch_async(concurrent_queue, ^{
//任务
});

- (void)viewDidLoad {
  dispatch_sync(dispatch_get_main_queue(), ^{
       [self doSomething];
  });
}

- (void)viewDidLoad {
  dispatch_sync(serial_queue, ^{
       [self doSomething];
  });
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        NSLog(@"1");
        dispatch_sync(global_queue, ^{
            NSLog(@"2");
            dispatch_sync(global_queue, ^{
                NSLog(@"3");
            });
            NSLog(@"4");
        });
        NSLog(@"5");
    }
    return 0;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(global_queue, ^{
        NSLog(@"1");
        [self performSelector:@selector(printLog) withObject:nil afterDelay:0];
        NSLog(@"3");
    });
}
- (void)printLog {
    NSLog(@"2");
}

dispatch_async(global_queue, ^{
     NSLog(@"读取1");
 });
dispatch_async(global_queue, ^{
     NSLog(@"读取2");
 });
dispatch_barrier_async(global_queue, ^{
     NSLog(@"写入1");
 });
dispatch_async(global_queue, ^{
     NSLog(@"读取3");
 });
dispatch_async(global_queue, ^{
     NSLog(@"读取4");
 });

// dispatch_group_notify
- (void)test {
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_queue_create("com.lqq.queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务1 - %@", [NSThread currentThread]);
        }
    });
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务2 - %@", [NSThread currentThread]);
        }
    });
    //--------------示例1-------------------
    // 写法一， 等上面的任务执行完成后，才会在主队列中执行任务3
//    dispatch_group_notify(group, queue, ^{
//        dispatch_async(dispatch_get_main_queue(), ^{
//            for (int i = 0; i < 5; i++) {
//                NSLog(@"任务3 - %@", [NSThread currentThread]);
//            }
//        });
//    });
    
    //写法二：直接在主队列中执行
//    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//        for (int i = 0; i < 5; i++) {
//            NSLog(@"任务3 - %@", [NSThread currentThread]);
//        }
//    });
    //--------------示例2-------------------
    // 如果有多个notify会怎么执行呢？
    dispatch_group_notify(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务3 - %@", [NSThread currentThread]);
        }
    });
    dispatch_group_notify(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务4 - %@", [NSThread currentThread]);
        }
    });
    // 任务3和任务4是交替执行的
}

// 监控任务是否完成，当完成时会返回0，不完成一直等待。
 long result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
 if (result == 0) {
     NSLog(@"全部任务执行完成");
 }

isReady
isExecuting
isFinished
isCanceled

start() -> 创建pthread -> main() ->[target performSelector:selector] -> exit()

GCD API介绍：
dispatch_queue_create(名称，类型)
类型为NULL时，为串行队列；为DISPATCH_QUEUE_CONCUREENT，为并行队列.。

需要手动release释放队列
dispatch_release(队列)

主队列，串行
dispatch_get_main_queue()
dispatch_get_global_queue(优先级，0)

优先级有四种情况：
    高，默认，低，后台
    
为自己创建的队列设置优先级

dispatch_set_target_queue(自定义队列，其他已知优先级的队列) 

dispatch_after(时间，队列，Block)
时间：dispatch_time_t 

dispatch_group 监听所有任务结束。

dispatch_group_create() //创建一个队列组，需要手动release
dispatch_group_async(组，队列，block)
dispatch_group_notify(组，队列，block) // 所有任务都结束后调用
也可以使用dispatch_group_wait()

dispatch_barrier_async() 一般用于数据库操作和文件读写。

同步任务
dispatch_sync(队列，block) 

异步任务
dispatch_async(队列，block)

指定执行次数
dispatch_apply(次数，队列，block)


挂起
dispatch_suspend(队列)

恢复
dispatch_resume(队列)

信号量
Dispatch Semaphore是持有计数的信号，该计数是多线程编程中的计数类型信号。

dispatch_semaphore_create(技术值)
dispatch_semaphore_wait(semaphore, 时间)
dispatch_semaphore_signal(semaphore)
dispatch_reliease(semaphore)

// 示例
// 创建一个对象，默认的计数值为0，等待。当计数值大于1或者等于1时，减去1而不等待。
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
// 发送计数值加一信号
dispatch_semaphore_signal(semaphore);
// 等待计数值变化，第二个参数是等待时间，这里是永久等待。
// 当计数值大于0时，返回0。等于0不会返回任何值。
long result = dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

if (result == 0) {
    NSLog(@"执行排他性操作");
}


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


dispatch I/O 分割读取，提高读取效率。