iOS多线程之 GCD (附实战实例)

原创文章 转载请注明出处, 谢谢! (～ o ～)Y

本文思维导图

GCD思维导图

GCD是什么

  • 全称是 Grand Central Dispatch
  • 纯C语言，提供了非常多强大的函数
  • GCD这部分代码苹果已开源，有兴趣的可以去下载了解一下 GCD源码

GCD的优势

GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核（比如双核、四核）
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码（但是更优的做法是我们自己管理线程，这个后面会说到）

GCD的两个核心

  • 任务：执行什么操作
  • 队列：用来存放任务

GCD使用的两个步骤

  • 创建任务：确定要做的事情
  • 将任务添加到队列中
    • GCD会自动将队列中的任务取出，放到对应的线程中执行
    • 任务的取出遵循队列的FIFO（First In First Out）原则：
      先进先出，后进后出

执行任务的方式

GCD中有2个用来执行任务的函数

  • 同步的方式执行任务
//queue：队列
//block：任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
  • 异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

队列的类型

GCD的队列可以分为2大类型

  • 并发队列（Concurrent Dispatch Queue）
    • 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
    • 并发功能只有在异步（dispatch_async）函数下才有效
  • 串行队列（Serial Dispatch Queue）
    • 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

小结

同步和异步决定了要不要开启新的线程

  • 同步：在当前线程中执行任务，不具备开启新线程的能力
  • 异步：在新的线程中执行任务，具备开启新线程的能力

并发和串行决定了任务的执行方式

  • 并发：多个任务并发（同时）执行
  • 串行：一个任务执行完毕后，再执行下一个任务

简单用法

串行队列，同步执行
  • 不会新建线程，按顺序执行任务(毫无用处) 补充:在GCDAsyncSocket 有这种用法 用于切换当前任务的执行queue
    GCDAsyncSocket
#define DISPATCH_QUEUE_SERIAL NULL
//串行队列
//dispatch_queue_t q = dispatch_queue_create("test", NULL);
dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
for (int i = 0; i < 10; i++) 
{
    //同步执行
    dispatch_sync(q, ^{
       NSLog(@"%@ -- %d",[NSThread currentThread],i);
    });
}
串行队列，异步执行
  • 会新建线程，按顺序执行任务(非常有用)
//只有一个线程，因为是串行队列，只有一个线程就可以按顺序执行队列中的所有任务
dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 10; i++) 
    {
        //异步执行
        dispatch_async(q, ^{
            NSLog(@"%@ -- %d",[NSThread currentThread],i);
        });
    }
并行队列，异步执行
  • 会新建多个线程，但是无法确定任务的执行顺序(有用，但是很容易出错)
dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i < 10; i++) 
    {
        //异步执行
        dispatch_async(q, ^{
            NSLog(@"%@ -- %d",[NSThread currentThread],i);
        });
    }
并行队列，同步执行
  • 不会新建线程，按顺序执行任务(几乎没用)
    dispatch_queue_t q = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i < 10; i++)
    {
        //异步执行
        dispatch_sync(q, ^{
            NSLog(@"%@ -- %d",[NSThread currentThread],i);
        });
    }

一些系统提供的队列

全局队列

  • 全局队列本质就是并发队列 
dispatch_get_global_queue(0,0);
  • 全局队列和并发队列的区别
  • 并发队列有名称，可以跟踪错误，全局队列没有
  • 在ARC中不需要考虑释放内存， dispatch_release(q);不允许调用。在MRC中需要手动释放内存，并发队列是create创建出来的 在MRC中见到create就要release，全局队列不需要release（只有一个）
  • 一般我们使用全局队列，但是建议同一类事情创建一个固定的队列进行管理，比如编写SDK我们不能使得我们的SDK导入的时候影响到别人队列里面的操作，导致别人莫名其妙导入你的SDK之后出现了卡顿，因此建议编写网络框架、处理绘图、编写其他轮子代码的时候创建一个自己专属的队列。

主队列

  • 主队列，异步任务
    • 不开线程，同步执行
    • 主队列特点：如果主线程正在执行代码暂时不调度任务，等主线程执行结束后在执行任务
    • 主队列又叫 全局串行队列
  • 主队列，同步执行
  • 程序执行不出来（死锁）
  • 死锁的原因，当程序执行到下面这段代码的时候
    主队列：如果主线程正在执行代码，就不调度任务
    同步执行：如果第一个任务没有执行，就继续等待第一个任务执行完成，再执行下一个任务此时互相等待，程序无法往下执行（死锁）
//主队列的特点:主队列只有当主线程空闲下来的时候才能够执行主队列里面的任务
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"哈哈");
    });

GCD 进阶

一次执行 dispatch_once

该函数的作用是保证block在程序的生命周期范围内只执行一次。最常用最常用的场景就是创建单例了

  • 单例模式
+ (instancetype)sharedManager {
    static id instance;
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[self alloc] init];
    });
    
    return instance;
}

延迟执行 Dispatch_after

  • dispatch_after是来延迟执行的GCD方法，因为在主线程中我们不能用sleep来延迟方法的调用，所以用dispatch_after是最合适的
  • dispatch_after能让我们添加进队列的任务延时执行，该函数并不是在指定时间后执行处理，而只是在指定时间追加处理到dispatch_queue 
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        <#code to be executed after a specified delay#>
    });

多次执行 dispatch_apply

把一项任务提交到队列中多次执行，具体是并行执行还是串行执行由队列本身决定.注意，dispatch_apply不会立刻返回，在执行完毕后才会返回，是同步的调用。

/*
    iterations  执行的次数  
    queue       提交到的队列  
    block       执行的任务
 */
dispatch_apply(size_t iterations,
               dispatch_queue_t queue,
               ^{
        <#code to be executed#>
    });

阻塞 dispatch_barrier

dispatch_barrier_async用于等待前面的任务执行完毕后自己才执行，而它后面的任务需等待它完成之后才执行。一个典型的例子就是数据的读写，通常为了防止文件读写导致冲突，我们会创建一个串行的队列，所有的文件操作都是通过这个队列来执行，比如FMDB，这样就可以避免读写冲突。

- (void)dispatch_barrier_async
{
    
    //创建一个并发队列
    dispatch_queue_t global_queue = dispatch_get_global_queue(0, 0);
    
    //异步把任务 放入 并发队列
    dispatch_async(global_queue, ^{
        NSLog(@"A开始 %@",[NSThread currentThread]);
        //模拟请求耗时
        sleep(2);
        NSLog(@"A完成 %@",[NSThread currentThread]);
    });
    
    dispatch_async(global_queue, ^{
        NSLog(@"B开始 %@",[NSThread currentThread]);
        sleep(1);
        NSLog(@"B完成 %@",[NSThread currentThread]);
    });
    
    dispatch_barrier_async(global_queue, ^{
        NSLog(@"dispatch_barrier_async");
    });
    
    dispatch_async(global_queue, ^{
        NSLog(@"C开始 %@",[NSThread currentThread]);
        sleep(3);
        NSLog(@"C完成 %@",[NSThread currentThread]);
    });

}

我们将写数据的操作放在dispatch_barrier_async中，这样能确保在写数据的时候会等待前面的读操作完成，而后续的读操作也会等到写操作完成后才能继续执行，提高文件读写的执行效率。

调度组 dispatch_group

当我们想在gcd queue中所有的任务执行完毕之后做些特定事情的时候，也就是队列的同步问题，如果队列是串行的话，那将该操作最后添加到队列中即可，但如果队列是并行队列的话，这时候就可以利用dispatch_group来实现了，dispatch_group能很方便的解决同步的问题。dispatch_group_create可以创建一个group对象，然后可以添加block到该组里面

  • dispatch_group_wait
    dispatch_group_wait会同步地等待group中所有的block执行完毕后才继续执行,类似于dispatch_barrier
  • dispatch_group_notify
    功能与dispatch_group_wait类似，不过该过程是异步的，不会阻塞该线程，dispatch_group_notify有三个参数
void dispatch_group_notify(dispatch_group_t group, //要观察的group
                         dispatch_queue_t queue,   //block执行的队列
                         dispatch_block_t block);   //当group中所有任务执行完毕之后要执行的block
  • dispatch_group_enter && dispatch_group_leave
    假如我们不想使用dispatch_group_async异步的将任务丢到group中去执行，这时候就需要用到dispatch_group_enter跟dispatch_group_leave方法，这两个方法要配对出现，以下这两种方法是等价的：
dispatch_group_async(group, queue, ^{ 
});

等价于

dispatch_group_enter(group);
dispatch_async(queue, ^{
　　dispatch_group_leave(group);
});

(具体用法在下面实际应用)

挂起队列 dispatch_suspend/ 恢复队列dispatch_resume

dispatch_suspend，dispatch_resume提供了“挂起、恢复”队列的功能简单来说，就是可以暂停、恢复队列上的任务。
但是这里的“挂起”，只能挂起队列后面正在排队的任务，并不能让当前正在执行的任务停止

- (void)dispatch_suspend_resume
{
    dispatch_queue_t queue = dispatch_queue_create("cn.jimmypeng", DISPATCH_QUEUE_SERIAL);
    //提交第一个block，延时5秒打印。
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"After 5 seconds...");
    });
    //提交第二个block，也是延时5秒打印
    dispatch_async(queue, ^{
        sleep(5);
        NSLog(@"After 5 seconds again...");
    });
    //延时一秒
    NSLog(@"sleep 1 second...");
    sleep(1);
    //挂起队列
    NSLog(@"suspend...");
    dispatch_suspend(queue);
    //延时10秒
    NSLog(@"sleep 10 second...");
    sleep(10);
    //恢复队列
    NSLog(@"resume...");
    dispatch_resume(queue);
}

Log:
16:24:27.565 GCD[10824:343675] sleep 1 second...
16:24:28.566 GCD[10824:343675] suspend...
16:24:28.567 GCD[10824:343675] sleep 10 second...
16:24:32.569 GCD[10824:343750] After 5 seconds...
16:24:38.568 GCD[10824:343675] resume...
16:24:43.571 GCD[10824:343750] After 5 seconds again...

在dispatch_suspend挂起队列后，第一个block还是在运行，并且正常输出。

信号量 dispatch_semaphore

信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。

但是这段文字可能过于抽象了，一般我们用停车的例子来阐释信号量控制线程的过程。

以一个停车场的运作为例。简单起见，假设停车场只有三个车位，一开始三个车位都是空的。这时如果同时来了五辆车，看门人允许其中三辆直接进入，然后放下车拦，剩下的车则必须在入口等待，此后来的车也都不得不在入口处等待。这时，有一辆车离开停车场，看门人得知后，打开车拦，放入外面的一辆进去，如果又离开两辆，则又可以放入两辆，如此往复。
在这个停车场系统中，车位是公共资源，每辆车好比一个线程，看门人起的就是信号量的作用。

在GCD中有三个函数是semaphore的操作，
分别是：

  • dispatch_semaphore_create 创建一个semaphore　（创建车位，可以传入参数创建多少个车位）
  • dispatch_semaphore_signal 发送一个信号　 （告诉看门人有一辆车走了，空出来一个车位）
  • dispatch_semaphore_wait 等待信号 （看门人看到车来了，如果有空车位 让车进去，没有空车位，让车按顺序等待空车位，可以设置等待时间，设置之后过了等待时间，车直接开走，不再进入车库）

(具体用法在下面实际应用)

GCD 进阶实际应用场景

异步下载图片 （异步请求，主线程刷新）

  • 单个任务
- (void)downLoadImage
{
    //下载图片耗费时间所以在子线程上面执行
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSURL *url = [NSURL URLWithString:@"http://a.hiphotos.baidu.com/image/pic/item/b21c8701a18b87d6ff2ca7bc030828381f30fd23.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        UIImage *img = [UIImage imageWithData:data];
        
     //刷新UI 在主线程刷新UI
        dispatch_async(dispatch_get_main_queue(), ^{
             NSLog(@"main_queue %@",[NSThread currentThread]);
          self.MyImageView.image = img;
        });
        
    });
}
  • 下载三首歌曲,不要求下载顺序,但是三首歌曲全部下载完成之后,提示用户需要在主线程 （调度组）
- (void)dispatch_group_demo1
{
    //创建一个调度组
    dispatch_group_t group = dispatch_group_create();
    
    //进入调度组
    dispatch_group_enter(group);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        //模拟请求耗时
        sleep(2);
        NSLog(@"A");
        //事件完成 离开调度组
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        sleep(1);
        NSLog(@"B");
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        sleep(3);
        NSLog(@"C");
        dispatch_group_leave(group);
    });
    
    //所有任务从调度组里面拿出来 调用通知
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"完成");
    });
}

- (void)dispatch_group_demo2
{

    //调度组
    dispatch_group_t group = dispatch_group_create();
    
    /*
     参数1:调度组
     参数2:队列
     参数3:任务
     */
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        sleep(1);
        NSLog(@"下载第1首歌曲");
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        sleep(1);
        NSLog(@"下载第2首歌曲");
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        sleep(1);
        NSLog(@"下载第3首歌曲");
    });
    //通知
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"歌曲下载完成");
    });

}

线程依赖 (异步串行/信号量)

  • 通过串行队列进行线程依赖
- (void)dispatch_serial_queue
{
       NSLog(@"开始");
    
    //创建一个串行队列
    dispatch_queue_t serial_queue = dispatch_queue_create("cn.jimmypeng", DISPATCH_QUEUE_SERIAL);
    
    //异步把任务 放入 串行队列
    dispatch_async(serial_queue, ^{
        NSLog(@"A开始 %@",[NSThread currentThread]);
        //模拟请求耗时
        sleep(2);
        NSLog(@"A完成 %@",[NSThread currentThread]);
    });
    
    dispatch_async(serial_queue, ^{
        NSLog(@"B开始 %@",[NSThread currentThread]);
        sleep(1);
        NSLog(@"B完成 %@",[NSThread currentThread]);
    });
    
    dispatch_async(serial_queue, ^{
        NSLog(@"C开始 %@",[NSThread currentThread]);
        sleep(3);
        NSLog(@"C完成 %@",[NSThread currentThread]);
    });
    
    NSLog(@"完成");
}

Log:
16:09:06.520 GCD[10457:323508] 开始
16:09:06.520 GCD[10457:323508] 完成
16:09:06.520 GCD[10457:323550] A开始 <NSThread: 0x600000073880>{number = 3, name = (null)}
16:09:08.524 GCD[10457:323550] A完成 <NSThread: 0x600000073880>{number = 3, name = (null)}
16:09:08.524 GCD[10457:323550] B开始 <NSThread: 0x600000073880>{number = 3, name = (null)}
16:09:09.525 GCD[10457:323550] B完成 <NSThread: 0x600000073880>{number = 3, name = (null)}
16:09:09.525 GCD[10457:323550] C开始 <NSThread: 0x600000073880>{number = 3, name = (null)}
16:09:12.529 GCD[10457:323550] C完成 <NSThread: 0x600000073880>{number = 3, name = (null)}
  • 通过信号量进行线程依赖
- (void)dispatch_semaphore
{
    NSLog(@"开始");
    //创建一个信号量容器
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    
    //进入调度组
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"A开始 %@",[NSThread currentThread]);
        //模拟请求耗时
        sleep(2);
        NSLog(@"A完成 %@",[NSThread currentThread]);
        //事件完成 离开调度组
        dispatch_semaphore_signal(semaphore);
    });
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"B开始 %@",[NSThread currentThread]);
        sleep(1);
        NSLog(@"B完成 %@",[NSThread currentThread]);
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"C开始 %@",[NSThread currentThread]);
        sleep(3);
        NSLog(@"C完成 %@",[NSThread currentThread]);
        dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    
    NSLog(@"完成");
}

Log:
16:06:15.030 GCD[10383:320049] 开始
16:06:15.031 GCD[10383:320105] A开始 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
16:06:17.036 GCD[10383:320105] A完成 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
16:06:17.037 GCD[10383:320105] B开始 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
16:06:18.042 GCD[10383:320105] B完成 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
16:06:18.043 GCD[10383:320105] C开始 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
16:06:21.044 GCD[10383:320105] C完成 <NSThread: 0x60800007aa80>{number = 3, name = (null)}
16:06:21.045 GCD[10383:320049] 完成

控制最大并发数 （信号量）

在iOS重写GCD之后，GCD的最大并发数就一发不可收拾了，之前笔者测试过最大的情况下甚至会开100多条并发线程来处理事务，这个我觉得还是比较浪费的，但是GCD又没有给出官方的设置最大并发数的方法，而在苹果新退出的NSOperation里面只要设置maxConcurrentOperationCount这个属性就能控制最大并发数。不知道是不是苹果的恶意想让我们选择更加面向对象的NSOperation，但是目前大部分的iOS开发者还是使用GCD的，所以下面跟大家说一下用GCD怎么控制最大并发数

@implementation CustomOperationQueue

- (id)initWithConcurrentCount:(int)count
{
      self = [super init];
      if (self) {
        if (count < 1) count = 5;
        semaphore = dispatch_semaphore_create(count);
        queue = Dispatch_queue_create("cn.jimmypeng", DISPATCH_QUEUE_CONCURRENT);
      }
    return self;
}

- (id)init 
{
      return [self initWithConcurrentCount:5];
}

- (void)addTask:(CallBackBlock)block
{
    dispatch_async(queue, ^{
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), 0), ^{
            block();
            dispatch_semaphore_signal(semaphore);
        });
    });
}

@end

在 addTask:方法中

  1. 当前的初始库存为5
  2. 第一次调用dispatch_semaphore_wait的时候会直接执行下去，并减少一个库存。每当完成一个任务之后，会执行到dispatch_semaphore_signal将库存添加回去。
  3. 当执行的任务为非常耗时的操作的时候，库存不能及时地还回去。而dispatch_semaphore_wait在仍然执行，库存最后会被减到0，这样dispatch_semaphore_wait就只能进行等待直到前面的任务有执行完成将存库有添加回去为止。

如此便完成了并发量的控制！

快速遍历

通常我们会用for循环遍历，但是GCD给我们提供了快速迭代的方法dispatch_apply，使我们可以同时遍历。比如说遍历0~5这6个数字，for循环的做法是每次取出一个元素，逐个遍历。dispatch_apply可以同时遍历多个数字。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_apply(6, queue, ^(size_t index) {
    NSLog(@"%zd------%@",index, [NSThread currentThread]);
});

原创文章 转载请注明出处, 谢谢! (～ o ～)Y

参考文献

dispatch_semaphore GCD信号量 -- 小胡子杰克
dispatch_suspend/dispatchp_resume -- thinkq
关于GCD开发的一些事儿 -- 树下老男孩
iOS多线程--彻底学会多线程之『GCD』 -- 行走的少年郎

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 214,588评论 6赞 496
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 91,456评论 3赞 389
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 160,146评论 0赞 350
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 57,387评论 1赞 288
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 66,481评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,510评论 1赞 293
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,522评论 3赞 414
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,296评论 0赞 270
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,745评论 1赞 307
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,039评论 2赞 330
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,202评论 1赞 343
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,901评论 5赞 338
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,538评论 3赞 322
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,165评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,415评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,081评论 2赞 365
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,085评论 2赞 352

推荐阅读更多精彩内容

  • iOS开发之多线程编程总结（二）
    背景 担心了两周的我终于轮到去医院做胃镜检查了！去的时候我都想好了最坏的可能（胃癌），之前在网上查的症状都很相似。...
    Dely阅读 9,234评论 21赞 42
  • iOS多线程浅汇-实战篇
    一、前言 上一篇文章iOS多线程浅汇-原理篇中整理了一些有关多线程的基本概念。本篇博文介绍的是iOS中常用的几个多...
    nuclear阅读 2,049评论 6赞 18
  • iOS GCD多线程
    程序中同步和异步是什么意思？有什么区别？ 解释一：异步调用是通过使用单独的线程执行的。原始线程启动异步调用，异步调...
    风继续吹0阅读 1,031评论 1赞 2
  • iOS多线程（二）--GCD详解
    目录：iOS多线程（一）--pthread、NSThreadiOS多线程（二）--GCD详解iOS多线程（三）--...
    Claire_wu阅读 1,073评论 0赞 6
  • 租个女友过七夕
    痴男怨女鹊桥会， 夕令一岁亦相逢。 欲求知音女相伴， 月下把酒共良宵。
    奇闻播客阅读 328评论 0赞 0