1:performSelector 多线程

/*
 *使用performSelector 的多线程
 *优点：简单
 *缺点：没有串行并线队列，不能实现高级线程调度
 */
 
-(void)performSelectorFunction{
    
    NSLog(@"performSelectorFunction start");

    //同步方式执行
    //[self performSelector:@selector(function1)];
    
    //延迟两秒执行,主线程阻塞
    //[self performSelector:@selector(function1) withObject:nil afterDelay:2];

    //主线程上执行，主线程阻塞，waitUntilDone:YES：等待执行完成顺序执行，waitUntilDone:NO 现执行后面语句
    //[self performSelectorOnMainThread:@selector(function1) withObject:nil waitUntilDone:NO];
    
    //子线程上执行
    [self performSelectorInBackground:@selector(function1) withObject:nil];
    
    NSLog(@"performSelectorFunction end");
    
}

2:NSThread

/*
 *使用NSThread 的多线程
 *优点：简单
 *缺点：没有串行并线队列，不能实现高级线程调度,和performSelector是一样的。
 */

-(void)NSThreadFunction{
    
    NSLog(@"NSThreadFunction start");
    
    //线程暂停 2秒
    //[NSThread sleepForTimeInterval:2];
    
    //显示创建的方式执行
    //NSThread *myThread = [[NSThread alloc]initWithTarget:self selector:@selector(function1) object:nil];
    //[myThread start];
    
    //静态方法执行线程
    //[NSThread detachNewThreadSelector:@selector(function1) toTarget:self withObject:nil];
    
    NSLog(@"NSThreadFunction end");
    
}

3:NSTimer(反面教材，他不是多线程，他只是定时执行任务)

/*
 *使反面教材，他不是多线程，他只是定时执行任务
 */

-(void)NSTimerFunction{
    
    NSLog(@"NSTimerFunction start");
    
    //定时执行任务，可以重复和不重复
    NSTimer *timer = [NSTimer scheduledTimerWithTimeInterval:2 target:self selector:@selector(function1) userInfo:nil repeats:NO];
    
    //暂时停止定时器
    //[timer setFireDate:[NSDate distantFuture]];
    //重新开启定时器
    //[timer setFireDate:[NSDate distantPast]];
    //永久通知定时器
    //[timer invalidate];
    //timer = nil;
    
    NSLog(@"NSTimerFunction end");
    
}

4:GCD最棒的多线程使用api

GCD 中主要的对象：

dispatch_sync
dispatch_async
dispatch_once_t
dispatch_after
dispatch_queue_t
dispatch_group_async
dispatch_barrier_async
dispatch_apply
dispatch_suspend，dispatch_resume
dispatch_sync
dispatch_sync
dispatch_sync


// dispatch_sync 同步方式执行：
 dispatch_sync(dispatch_get_global_queue(0, 0), ^{
      // something
 });


// dispatch_async 异步执行：
 dispatch_async(dispatch_get_global_queue(0, 0), ^{
      // something
 });

 // dispatch_async：主线程执行：
 dispatch_async(dispatch_get_main_queue(), ^{
      // something
 });

 // dispatch_once：一次性执行：
 static dispatch_once_t onceToken;
 dispatch_once(&onceToken, ^{
     // code to be executed once
 });

 //dispatch_time_t ：延迟2秒执行：
 double delayInSeconds = 2.0;
 dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
 dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
     // code to be executed on the main queue after delay
 });

 //dispatch_group_t： 合并汇总结果
 dispatch_group_t group = dispatch_group_create();
 dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
      // 并行执行的线程一
 });
 dispatch_group_async(group, dispatch_get_global_queue(0,0), ^{
      // 并行执行的线程二
 });
 dispatch_group_notify(group, dispatch_get_global_queue(0,0), ^{
      // 汇总结果
 });


 //dispatch_barrier_async :作用是在并行队列中，等待前面的队列执行完成后在继续往下执行
dispatch_queue_t concurrentQueue = dispatch_queue_create("my.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentQueue, ^(){
    NSLog(@"dispatch-1");
});
dispatch_async(concurrentQueue, ^(){
    NSLog(@"dispatch-2");
});
dispatch_barrier_async(concurrentQueue, ^(){
    NSLog(@"dispatch-barrier"); 
});
dispatch_async(concurrentQueue, ^(){
    NSLog(@"dispatch-3");
});
dispatch_async(concurrentQueue, ^(){
    NSLog(@"dispatch-4");
});

//dispatch_apply：将一个指定的block执行指定的次数，常用语block数组。在一般方法中虽然block中的方法并不是顺序执行，但是由于apply是线程同步的，
//所以print(dispatch_apply done);一定最后执行。常常可以这样用：
let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
dispatch_async(globalQueue, { () -> Void in
    dispatch_apply(10, globalQueue) { (index) -> Void in
        print(index)
    }
    print("completed")
})
print("在dispatch_apply之前") 


//dispatch_suspend / dispatch_resume
//暂停
dispatch_suspend(globalQueue)
//恢复
dispatch_resume(globalQueue)

//Dispatch Semaphore 这个是线程的信号量，比较复杂