GCD

3.GCD

GCD的全称是Grand Central Dispatch,提供了非常多的纯C语言的函数

GCD的优势

优势:性能非常好
1.GCD是苹果公司为多核并行运算提出的解决方案
2.GCD会自动利用更多的CPU内核(比如双核,四核)
3.GCD会自动管理线程的生命周期(创建线程,调度线程,销毁线程)
4.程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码

GCD的两个核心的概念 (任务和队列)
  • 任务:是指执行什么操作
    • 执行任务的方式:
      分为"同步执行""异步执行"两种方式
      **同步执行 : **如果我(当前的任务)没有执行完毕,后边的任务将永远无法执行
      **异步执行 : **我(当前的任务)无所谓,我没执行完,后面的也可以执行
  • 执行任务时常用的函数
    分为"同步函数""异步函数"两种函数
    **同步函数(dispatch_sync) : **只能在当前线程中执任务,不具备开启新线程的能力(永远不开线程)
参数: queue :队列    block:任务
          dispatch_sync(<#dispatch_queue_t queue#>, <#^(void)block#>)

**异步函数(dispatch_async) : **可以在新的线程中执行任务,具备开启新的线程的能力(具备不代表一定要开启)

参数: queue :队列    block:任务
          dispatch_async(<#dispatch_queue_t queue#>, <#^(void)block#>)
  • 使用GCD的两个步骤
    1.定制任务:确定想做的事情
    2.将任务添加到队列中
    1.GCD会自动将队列中的任务取出,放到对应的线程中执行
    2.任务的取出会遵循队列的FIFO原则:先进先出,后今后出(类似一个管道,先进去的,先从另一面出来))
  • 队列:是用来存放什么任务
    GCD中的队列分为两种:并发队列串行队列
    • 串行队列
      让任务一个接着一个的执行(上一个任务执行完毕后,再执行下一个任务)
      • 串行队列分为两种:自己创建的的串行队列主队列
//自己创建的串行队列
dispatch_queue_t queue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
//主队列
dispatch_queue_t queue2 = dispatch_get_main_queue();
  • 并发队列
    可以让多个任务同时执行,不过并发队列的这种特性只有在异步函数下才有效果(因为同步函数没有添加子线程的能力)
    "并发"的解释:指的是多个任务同时执行的"现象",并且要求有子线程
    - 可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
    - 并发功能只有在"异步函数(dispatch_async)"下才会有效

    • 并发队列分为两种:自己创建的并发队列全局并发队列
//自己创建的并发队列
dispatch_queue_t queue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
//全局并发队列
系统内部默认提供4个全局并发队列的优先级如下:
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 中
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台
//获取全局并发队列(系统启动就已经有了)
dispatch_queue_t queue1 = dispatch_get_global_queue(DISPATCH
_QUEUE_PRIORITY_DEFAULT, 0);
//参数解释
第一个参数:传入某一个全局并发队列
第二个参数:写0(没有用的参数);
  • 并发队列和串行队列执行任务的方式
    并发队列 : 执行任务的方式是将队列中的任务一次性依次取出来,拿到外边执行任务,并发队列将任务取出来之后就不再关心你怎么执行了
    串行队列 : 将队列中的任务先取出第一个,到外边执行,并监听这个任务是否执行完毕,如果执行完毕再取出第二个任务来执行任务,并继续监听
GCD的基本使用
  • 1.创建队列
"第一个参数:"C语言的字符串,给队列起一个名字或者是标识
*注意* : 函数都是C语言的函数,在写字符串的时候,不要加@
         通常命名规范为公司域名加功能,"例如:com.xxx公司域名.www.download"
"第二个参数:"队列的类型      
 DISPATCH_QUEUE_CONCURRENT  并发
 DISPATCH_QUEUE_Serial      串行队列 
//获取并发队列
dispatch_queue_t queue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
//获取串行队列
dispatch_queue_t queue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
  • 2.使用函数封装任务,并添加到队列中
"第一个参数" : 队列
"第二个参数" : block 用来封装任务
//异步函数封装
dispatch_async(queue, ^{
       for (NSInteger i = 0; i <10; i++) {
           NSLog(@"%zd----------",i);
       }
 });
//同步函数封装
dispatch_sync(queue, ^{
       for (NSInteger i = 0; i <10; i++) {
           NSLog(@"%zd----------",i);
       }
});
队列与函数的组合
  • 1.异步函数 + 并发队列 - 异步函数会开多条子线程,队列的任务是并发执行
//异步函数 + 并发队列
(会开辟多个子线程,并且任务是在新开辟的多个子线程内分别执行任务,
无论是在主线程中调用test方法还是在非主线程总调用test方法,都会开启多个子线程,
并且在新开辟的多个子线程内,并发执行任务)
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"async + concurrent--------1--------%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"async + concurrent--------2--------%@",[NSThread currentThread]);
    });
  • 2.异步函数 + 串行队列 - 只开启一条子线程,队列里的任务是串行执行的,串行执行一定是按顺序执行的
    ** 注意:**异步函数+ 串行队列只要不是在主队列,一定会开一条子线程
//异步函数 + 串行队列
(会开辟一个子线程,并且在子线程内串行执行任务,
无论是在主线程中调用test方法还是在非主线程中调用test方法,都会开辟一个子线程,
并且在这个开辟的子线程内串行执行任务)
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
        NSLog(@"async + serial-------1--------%@",[NSThread currentThread]);
    });
dispatch_async(queue, ^{
        NSLog(@"async + serial-------2--------%@",[NSThread currentThread]);
    });
  • 3.同步函数 + 并发队列 - 不会开新的线程,所有的任务只会在当前线程中串行执行
    ** 注意:**同步函数不一定都是在主线程中执行,只有正在主队列中才会在主线程中执行
//同步函数 + 并发队列
(在当前线程中串行执行,不会开辟子线程,
如果是在主线程中调用test,那么当前线程就是主线程;
如果是在非主线程中调用,那么当前线程就是子线程,同步函数也是在当前线程中执行)
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
        NSLog(@"sync + concurrent------1-----%@",[NSThread currentThread]);
    });
dispatch_sync(queue, ^{
        NSLog(@"sync + concurrent------2-----%@",[NSThread currentThread]);
    });
  • 4.同步函数 + 串行队列 - 不会开新的线程,所有的任务只会在当前线程中串行执行
//同步函数 + 串行队列
(在当前线程中串行执行,
如果是在主线程中调用test方法,当前线程是主线程;
如果是在非主线程中调用这个方法,当前线程就是子线程,同步函数也是在当前线程中执行)
dispatch_queue_t queue = dispatch_queue_create("sync + serial", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
        NSLog(@"sync + serial----1---%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"sync + serial----2---%@",[NSThread currentThread]);
    });
特殊队列与函数的组合
  • 全局并发队列 + 异步函数
//全局并发队列 + 异步函数
(会开辟多个子线程,并且任务是在新开辟的子线程内执行,
无论是在主线程中调用test方法,还是在非主线程中调用test方法,那么都会开辟多个子线程,
并且任务是在新开辟的子线程内以并发的方式执行)
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"async + globalQueue --------1---------%@",[NSThread currentThread]);
    });
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"async + globalQueue --------2---------%@",[NSThread currentThread]);
    });
  • 全局并发队列 + 同步函数
//全局并发队列 + 同步函数
(如果是在主线程中调用test方法,那么任务是在主线程中以串行的方式执行,不会开辟子线程,
如果是在非主线程中调用test方法,那么任务是在调用test方法的非主线程内,以串行方式执行,不会开辟子线程)
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"sync + globalQueue -------1--------%@",[NSThread currentThread]);
    });
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"sync + globalQueue -------2--------%@",[NSThread currentThread]);
    });
  • 主队列 + 异步函数
//主队列 + 异步函数
(不会开辟子线程,任务在当前主线程中以串行的方式执行,
无论是在主线程中调用test方法还是在非主线程中调用test方法,
任务都是在主线程中以串行的方式执行)
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"async + mainQueue--------1-------%@",[NSThread currentThread]);
    });
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"async + mainQueue--------2-------%@",[NSThread currentThread]);
    });
  • 主队列 + 同步函数(会形成死锁)
//主队列 + 同步函数
(形成死锁,在主队列中的任务,只能在主线程中执行,
如果是在主线程中调用test方法,当前线程是主线程,那么会形成死锁,
如果是在非主线程中调用test方法,那么不会形成死锁,
并且任务是在主线程中,以串行的方式执行)
    NSLog(@"来到了test方法内");
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"sync + mainQueue ----------1--------%@",[NSThread currentThread]);
    });
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"sync + mainQueue ----------2--------%@",[NSThread currentThread]);
    });
主队列的特点:  
  1.凡是在主队列中的任务,都必须要在主线程中来执行,它与全局并发队列相同,也是在程序一启动就默认存在的队列
  2.主队列在调度任务的时候,会先检查主线程的状态,如果发现主线程处于繁忙状态,就会暂停调度
//死锁形成的原因
    同步函数会监听当前任务完成后,再执行下一个任务,
    也就是说,同步函数 会等到 刚添加到主队列的 block 执行完成才会返回,
    然而主队列是串行队列,同步函数中的 block 是后加入的,前一个是主线程正在执行的方法(当前的主线程在执行 同步函数函数 所在的方法),
    所以 同步函数 想执行 block 必须等待主线程执行完成,而主线程又在等待 同步函数 返回,去执行后续内容。
    同步函数 等待 主线程 执行完成, 主线程 等待 同步函数返回 ,这样就造成死锁
GCD的常用函数
1.延迟执行函数
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"GCD----%@",[NSThread currentThread]);
      });
 /*
      第一个参数:delayInSeconds 要延迟的时间 GCD的时间是以纳秒为单位
     第二个参数:队列  决定block中的任务在哪个线程中执行
     */
**作用 : **延迟一段时间后再执行,可以通过设置队列,指定block在哪个线程中调用
**原理 : **延迟把block内容提交到队列而不是先将block添加到队列后再延迟调度
//例如下面的工程中,执行到after的时候会延迟4秒再提交到队列,
//在并发的情况下,这4秒足以把队列中其他的任务都处理完毕了,
//所以,delay mission是最后才被执行的
dispatch_queue_t queue = dispatch_queue_create("com.lyu.www.test", DISPATCH_QUEUE_CONCURRENT);    
dispatch_async(queue, ^{        
      NSLog(@"first mission");    
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"delay mission");
    });   
 dispatch_async(queue, ^{        
    NSLog(@"last mission");
    });
**注意 : **dispatch_after方法本身是异步的
**拓展 : **
除了GCD的延迟的方法,还有两种延迟执行的方法:
// 主循环的延迟执行的方法
//afterDelay 延迟的时间 秒为单位 2.0秒
[self performSelector:@selector(task) withObject:nil afterDe
lay:2.0];
//定时器的延迟执行
[NSTimer scheduledTimerWithTimeInterval:2.0 target:self sele ctor:@selector(task) userInfo:nil repeats:NO];
2.GCD的一次性函数
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
      NSLog(@"---once---");
});

作用:
1.能够保证在整个程序运行过程总,block中的代码只会执行一次
判断方法:使用静态变量记录当前block有没有被执行过,如果执行过来就不会再执行了
2.(重要)线程是安全的
3.应用:单例模式
使用方法
1.首先要定义一个dispatch_once_t变量,用于记录代码重复的次数;
2.然后敲dispatch_once代码块,执行某段代码,利用变量来控制如果不是第一次执行就不执行

3.GCD的栅栏函数

主要用于异步函数+并发队列,因为同步函数一定是串行执行的
任务执行顺序 : **
栅栏函数之前的任务(执行完毕)--> 栅栏函数的任务(执行完毕)--> 栅栏函数
之后的任务
注意点 : **
1.栅栏函数只能对自己创建的并发队列有效
(对全局并发队列无效)

2.所有要通过栅栏控制顺序的任务要放在同一个队列中
3.如果要使用主队列, 则要注意不要在主线程执行含有同步函数的方法(同步函数的任务会被加到主队列), 否则死锁

dispatch_barrier_async(queue, ^{ 
     NSLog(@"栅栏函数");
 });

**作用 : **
1.能过控制队列中,任务的执行顺序
2.只要添加栅栏函数,就能保证,栅栏函数前的任务先执行完后,再执行栅栏函数后的任务

示例:
//创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("barrier", DISPATCH_QUEUE_CONCURRENT);    //用函数封装方法,并添加到队列中
    dispatch_async(queue, ^{  NSLog(@"栅栏前任务1",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏前任务2",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏前任务3",);  });
    //栅栏函数,
    dispatch_barrier_async(queue, ^{  NSLog(@"+++++++++++++++++++"); });
    //普通的异步函数
    dispatch_async(queue, ^{  NSLog(@"栅栏后任务1",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏后任务2",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏后任务3",);  });
//运行结果:前三个任务是无序的,后三个任务也是无序的,但是前三个任务会先执行,执行完毕之后再执行后三个任务
4.GCD的迭代

GCD的迭代,其实就是遍历,只是普通的遍历都是在当前的线程中串行执行的,遍历的效率不高
GCD的迭代是在多个线程(包括主线程)中,并发的执行的,执行效率相比较普通的遍历要高一些
** 注意:** 1)不能使用主队列,否则会发生死锁,因为主队列也会一起参与迭代

//第一个参数:要迭代的次数
//第二个参数:队列 (注意点:不能使用主队列)
//第三个参数:blocks(设置索引)
dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t i) {
       NSLog(@"%zd---%@",i,[NSThread currentThread]);
});

快速迭代与死锁:
死锁问题:因为主线程会一起参与迭代,所以如果在主队列执行迭代的话,再加上主线程的特性,会造成死锁

dispatch_queue_t queue = dispatch_get_main_queue();  //主线程死锁
NSLog(@"死锁之前"); 
dispatch_apply(10, queue, ^(size_t i) {        
      NSLog(@"%ld--%@",i,[NSThread currentThread]);
  });

问题点:快速迭代中所有的任务都是在多个线程中(包括主线程)中并发执行的(无序执行的)

GCD迭代函数应用的示例:

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{   
 //获取被剪切文件的原始路径    
NSString * fromPath = @"/Users/mario/Desktop/from";    
//获取被剪切文件的目标路径    
NSString * toPath = @"/Users/mario/Desktop/to";    
//获取被剪切文件的原始路径内的子路径数    
NSArray * subPathArray = [[NSFileManager defaultManager] subpathsAtPath:fromPath];   
//获取子路径的个数
NSInteger count = subPathArray.count;
//迭代遍历    
//第一个参数:遍历的次数    
//第二个参数:队列(注意不要用主队列,因为主线程和子线程会一起执行迭代任务)
    dispatch_apply(count, dispatch_get_global_queue(0, 0), ^(size_t index) {
        //获取完成的原始路径        
        NSString * fromFullPath = [fromPath stringByAppendingPathComponent:subPathArray[index]];                
        //获取完整的目标路径
        NSString * toFullPath = [toPath stringByAppendingPathComponent:subPathArray[index]];
        //将要剪切的文件从原来文件夹中移动到目标文件夹        
        [[NSFileManager defaultManager] moveItemAtPath:fromFullPath toPath:toFullPath error:nil];          
        //打印当前路径
         NSLog(@"--------%@",[NSThread currentThread]);
    });
}

//补充:
如何得到文件路径下的所有文件 : subpathsAtPath:
如何拼接文件全路径 : stringByAppendingPathComponent
移动文件的方法:
//参数解释
//第一个参数:文件在哪里
//第二个参数:移动到哪里
//第三个参数:错误信息,可以给nil
[[NSFileManager defaultManager] moveItemAtPath:fromeFullPath toPath:toFullPath error:nil];
5.GCD的队列组

应用场景:用于只有在某些任务执行完毕之后,才能执行指定的任务

  • 实现队列组的函数:方式一
//获取队列组管理队列
dispatch_group_t group =dispatch_group_create();
//队列组监听任务是否执行完成
 dispatch_group_async(group, queue, ^{ });
//拦截通知 
dispatch_group_notify
示例:
-(void)group1{   
//1.获得队列组管理队列    
dispatch_group_t group = dispatch_group_create();    
//2.获得并发队列
dispatch_queue_t queue = dispatch_queue_create("group", DISPATCH_QUEUE_CONCURRENT);
//通过队列组监听队列中任务的执行状态
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad1-----%@",[NSThread currentThread]); });
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad2-----%@",[NSThread currentThread]); });
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad3-----%@",[NSThread currentThread]); });
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad4-----%@",[NSThread currentThread]); });
//拦截通知,当队列组内的所有任务都执行完毕后,会调用这个方法
//保证队列组中所有的下载任务完成之后再刷新UI界面
dispatch_group_notify(group, queue, ^{  
    NSLog(@"----end-----%@",[NSThread currentThread]);  });
    NSLog(@"++++++++++++++++%@",[NSThread currentThread]);
}
  • 实现队列组的函数:方式二
    dispatch_group_enter & dispatch_group_leave这个两个方法是成对使用的
//进入队列组
dispatch_group_enter(group);
//任务执行完毕后,离开队列组
dispatch_group_leave(group);
示例:
-(void)group2{    
//获取队列组    
dispatch_group_t group = dispatch_group_create();    
//获取队列
dispatch_queue_t queue = dispatch_queue_create("group2", DISPATCH_QUEUE_CONCURRENT);
//将异步的任务纳入队列组中进行监视    dispatch_group_enter(group);
dispatch_async(queue, ^{  NSLog(@"downLoad1-----%@",[NSThread currentThread]);
        //通知队列组,该任务已经完成
        dispatch_group_leave(group);   
//注意:一定要写在封装任务的函数内});
dispatch_group_enter(group);
dispatch_async(queue, ^{  NSLog(@"download2-----%@",[NSThread currentThread]);
         dispatch_group_leave(group); });
dispatch_group_enter(group);
dispatch_async(queue, ^{  NSLog(@"download3-----%@",[NSThread currentThread]);
         dispatch_group_leave(group); });
//拦截通知    
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 0.0001 * NSEC_PER_SEC);    
long num = dispatch_group_wait(group, time);    
NSLog(@"%ld",num);
}

**注意 : **
1.将多个任务添加到队列组中不影响队列的原本的同步异步性,
2.所有的函数,包括队列组之外的任务的同步/异步性都没有影响
比如:有N个任务,添加到队列组M个任务,队列组内的M个任务和队列组外的N-M个任务的同步/异步的执行是不受影响的,和之前一样
3.dispatch_group_notify是异步函数,只有当队列组中所有的任务全部执行完,才会执行这个函数的回调的内容,不论放在哪个位置,永远是队列组内最后执行的

拦截队列通知的方法
**方法一 : **dispatch_group_notify

         dispatch_group_notify(group, queue, ^{
             NSLog(@"--end---");
         });

**方法二 : ** dispatch_group_wait等待队列组里的任务的执行(需要设置等待时间),是同步函数
注意 : dispatch_group_wait方法是与队列组中的任务同步执行的,与(notify异步不同)

dispatch_time_t timer = dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC);
时间参数解读:当前传入的时间是2秒,意味着只等2秒,不管队列中的任务有没有执行完毕都会继续往下执行
如果时间传入的是 DISPATCH_TIME_FOREVER(死等),一直要等到队列组中所有的任务都执行完毕之后,才会继续往下执行

long n = dispatch_group_wait(group, timer);
//如果在timer时间内完成所有的任务,那么就返回0,否则返回非零值(注意不一定是1)

dispatch_async_f介绍
是一个异步函数,该方法使用函数来封装任务
第二个参数:要调用函数的参数(可以不传,不传就传一个NULL)
第三个参数:要调用的函数

dispatch_async_f函数.png

dispatch_async_f的使用.png
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 151,829评论 1 331
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 64,603评论 1 273
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 101,846评论 0 226
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 42,600评论 0 191
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 50,780评论 3 272
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 39,695评论 1 192
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 31,136评论 2 293
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,862评论 0 182
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 33,453评论 0 229
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,942评论 2 233
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,347评论 1 242
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,790评论 2 236
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 32,293评论 3 221
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,839评论 0 8
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,448评论 0 181
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 34,564评论 2 249
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 34,623评论 2 249

推荐阅读更多精彩内容

  • 目录(GCD): 关键词 混淆点 场景应用 总结 1. 关键词 线程概念: 独立执行的代码段,一个线程同时间只能执...
    Ryan___阅读 1,202评论 0 3
  • iOS 多线程系列 -- 基础概述iOS 多线程系列 -- pthreadiOS 多线程系列 -- NSThrea...
    shannoon阅读 799评论 0 2
  • #import "ViewController.h" @interface ViewController () @...
    艾克12138阅读 186评论 0 0
  • 900米海拔处的19亩茶山 茶山中放养的黄牛 一路遇到的风景
    念醇Y阅读 381评论 0 2
  • 前世 日暮宫台上,系马高墙边。 律鞭行西市,笑入酒肆中。 胡姬半遮纱,琥珀泻玲珑。 玉步随身转,珠璧牵裙翻。 执鼓...
    长安旧人阅读 253评论 3 4