iOS多线程(三)：多线程实现方案(GCD)

在iOS多线程实现方案中，使用最多的就是GCD了。GCD，英文全称是Grand Central Dispatch，是苹果为多核的处理器提出的一套实现多线程编程的解决方案。

前文已经记录过了pThread和NSThread：
iOS多线程(一)：基本概念和生命周期
 iOS多线程(二)：多线程实现方案(pthread、NSThread)

下面是四种实现方式的比较：

多线程实现方式比较

1、GCD

如上图四种实现方式的比较可以看出，GCD是基于C语言的一套多线程实现方案，使用起来非常方便。开发者只需要编写需要做什么的代码，线程相关的管理都交给系统来处理。

GCD中有几个概念需要先了解：

1.1 队列和任务

任务：是一段需要执行的操作代码块，执行方式有同步执行和异步执行。

同步执行，会在当前线程中执行，不具备开辟新线程的能力，会阻塞当前线程，直到需要执行的代码完毕。
异步执行，会开辟一个新的线程执行需要的新操作，而当前线程会直接往下继续执行，不会被阻塞。

队列：用来存放任务，有两种队列，串行队列和并行队列。

串行队列会按先进先出一个一个取出来，然后一个一个执行。
并行队列，也是按先进先出一个一个取出来，但是它是在不同的线程中执行，但是GCD也不会无限制的一直创建新线程，会根据当前的系统资源的分配情况来控制并发的线程数。

所以，GCD的使用实际上包含了两个步骤：

确定要执行的任务，即自己想要实现什么。
将任务添加到队列中。

1.2 创建队列

主队列，程序运行后就默认开启的队列，它是一个特殊的串行队列，并且规定UI的刷新都需要在主队列中执行，一般耗时的操作则最好不要在主队列执行，以免阻塞。

// 获取主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();

主队列以外的队列，即一般是自己创建的队列。

 /**
     * 第一个参数const char *label，可以看出是一个C语言字符串，自己定义一个名字
     * 第二个参数，想要把这个队列定义成什么类型
     * 队列类型：DISPATCH_QUEUE_SERIAL表示串行u队列
     * 队列类型：DISPATCH_QUEUE_CONCURRENT表示并行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("jc-test-queue", DISPATCH_QUEUE_SERIAL);

如果队列类型传NULL，默认表示为串行队列。

GCD默认还提供了四个全局并发队列，供整个应用使用，可以无需手动创建。

 /**
     * 第一个参数为优先级，根据四个优先级默认提供了四个全局队列
     * DISPATCH_QUEUE_PRIORITY_HIGH 优先级最高
     * DISPATCH_QUEUE_PRIORITY_DEFAULT 默认有限级
     * DISPATCH_QUEUE_PRIORITY_LOW 优先级低
     * DISPATCH_QUEUE_PRIORITY_BACKGROUND 后台运行，优先级最低
     * 第二个参数，预留参数，一般设置为0
     */
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);

1.3 创建任务

创建任务的基本方法主要是两个，dispatch_sync(queue, block)和dispatch_async(queue, block)。分别是创建同步任务和异步任务的方法。

 // 创建同步任务
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"current:%@", [NSThread currentThread]);
    });
    // 创建异步任务
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"current:%@", [NSThread currentThread]);
    });

其中括号中的第一个参数传递任务执行在哪个队列中，一般可以是主队列、自定义队列和全局队列。第二个参数是一个block，包含了需要执行的代码。
注：注意在使用block时的循环引用问题。

1.4 队列组

在开发中，经常会遇到C任务需要在A任务和B任务都执行完毕后再执行，而A和B执行顺序又没有要求的场景，这个时候GCD也为我们提供了一个队列组的概念可以实现如上需求。
队列组是将多个队列添加到一个队列组中，当这个队列的所有任务都执行完了，可以通过一个通知来告知外部。

// 创建队列组
    dispatch_group_t group = dispatch_group_create();
    // 创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 任务，只有异步方法
    // 任务1
    dispatch_group_async(group, queue, ^{
        for (NSInteger i=0; i<3; i++) {
            NSLog(@"group - 01 - %@", [NSThread currentThread]);
        }
    });
    // 任务2
    dispatch_group_async(group, queue, ^{
        for (NSInteger i=0; i<6; i++) {
            NSLog(@"group - 02 - %@", [NSThread currentThread]);
        }
    });
    // 任务3
    dispatch_group_async(group, queue, ^{
        for (NSInteger i=0; i<4; i++) {
            NSLog(@"group - 03 - %@", [NSThread currentThread]);
        }
    });
    // 所有的组任务完成之后拦截通知，然后再执行其他的操作
    dispatch_group_notify(group, queue, ^{
        NSLog(@"组任务完成了：%@", [NSThread currentThread]);
    });

注：组任务只有异步方法。

1.5 栅栏函数

栅栏函数可以实现具有依赖关系的不同任务，比如任务1和任务2执行完后再执行任务3和任务4，这个时候就需要用到栅栏函数。

先来看一下如果我们使用上面的队列组是否也能达到预期效果呢？举这个栗子也能更好了的理解队列组的使用场景。

// 创建队列组
    dispatch_group_t group = dispatch_group_create();
    // 创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"group - 01 - %@", [NSThread currentThread]);
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"group - 02 - %@", [NSThread currentThread]);
    });
    // 所有的组任务完成之后拦截通知，然后再执行其他的操作
    dispatch_group_notify(group, queue, ^{
        NSLog(@"组任务完成了：%@", [NSThread currentThread]);
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"group - 03 - %@", [NSThread currentThread]);
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"group - 04 - %@", [NSThread currentThread]);
    });

如果一不留神，上面的预期结果可能就会被我们认为是01-02-完成-03-04。而实际的输出结果是，最后执行的永远是dispatch_group_notify中的任务。具体底层的实现原理，以后会详细讲解。

2019-06-19 22:01:08.867652+0800 Thread-Test[2666:96238] group - 01 - <NSThread: 0x600000324200>{number = 3, name = (null)}
2019-06-19 22:01:08.867653+0800 Thread-Test[2666:96242] group - 04 - <NSThread: 0x600000316240>{number = 6, name = (null)}
2019-06-19 22:01:08.867659+0800 Thread-Test[2666:96247] group - 03 - <NSThread: 0x600000316180>{number = 4, name = (null)}
2019-06-19 22:01:08.867688+0800 Thread-Test[2666:96237] group - 02 - <NSThread: 0x600000330d40>{number = 5, name = (null)}
2019-06-19 22:01:08.867960+0800 Thread-Test[2666:96237] 组任务完成了：<NSThread: 0x600000330d40>{number = 5, name = (null)}

回到栅栏函数，为实现上面这个需求，就需要有一个大坝似的东西把任务分成两截来执行，这就出现了栅栏函数。栅栏函数有两个方法：dispatch_barrier_sync和dispatch_barrier_async。从字面上可以看出一个是同步的，一个是异步的。这里同步和异步的实际意义是，dispatch_barrier自身包含的任务与它后面的任务是同步执行还是异步执行，即：

dispatch_barrier_sync在执行完它前面的任务后，会把自己block中的任务插入到队列中，先执行完自己的block，再执行barrier后面的任务。
dispatch_barrier_async相同的是，也会先执行完它前面的任务，然后直接把它后面的任务插入到队列中，不需要等它自己block中的任务执行完。

先来看dispatch_barrier_sync举例：

// 创建队列
    dispatch_queue_t queue = dispatch_queue_create("barrier_test", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
       NSLog(@"barrier - 01 - %@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"barrier - 02 - %@", [NSThread currentThread]);
    });
    
    // 所有的组任务完成之后拦截通知，然后再执行其他的操作
    dispatch_barrier_sync(queue, ^{
        NSLog(@"barrier - in - %@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"barrier - 03 - %@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"barrier - 04 - %@", [NSThread currentThread]);
    });

按照上面的定义，这段代码的输出是：

2019-06-19 22:18:47.917620+0800 Thread-Test[2722:102068] barrier - 01 - <NSThread: 0x600001b6d540>{number = 3, name = (null)}
2019-06-19 22:18:47.917621+0800 Thread-Test[2722:102064] barrier - 02 - <NSThread: 0x600001b5ad40>{number = 4, name = (null)}
2019-06-19 22:18:47.918567+0800 Thread-Test[2722:102032] barrier - in - <NSThread: 0x600001b3cdc0>{number = 1, name = main}
2019-06-19 22:18:47.918716+0800 Thread-Test[2722:102064] barrier - 03 - <NSThread: 0x600001b5ad40>{number = 4, name = (null)}
2019-06-19 22:18:47.918727+0800 Thread-Test[2722:102068] barrier - 04 - <NSThread: 0x600001b6d540>{number = 3, name = (null)}

任务03和04一定会在barrier函数的代码段后面执行。但是如果换成dispatch_barrier_async，按照定义03和04与barrier中的任务是并行的，不过实际操作中看到的输出结果是03和04同样都会在barrier函数任务执行后才执行，这里留点疑问。

使用栅栏函数时需要注意的一点是，一般是需要使用自定义队列才有意义, 如果用的是串行队列或者系统提供的全局并发队列, 这个栅栏函数就相当于一个同步函数。

1.6 信号量

信号量可以理解为一个资源管理器，前面已经讲过GCD中的好几种场景的实现，但是还有一种场景需要考虑，那就是如果我们想控制一次并发的线程数量该怎么处理呢？就比如常见的一个例子，通过网络请求下载多张图片，为了不让下载过程过度的占用资源，需要控制最大的开辟线程的数量，这个时候就可以使用信号量。

信号量概念里主要有三个函数：

dispatch_semaphore_create(M)
用来创建一个值为M的信号量，如果初值小于0则会返回NULL
dispatch_semaphore_wait(信号量对象，等待时间)
如果该信号量的值大于0，则使其信号量的值减1，否则，阻塞线程直到该信号量的值大于0或者达到等待时间。
dispatch_semaphore_signal(信号量)
用来提高信号量，使信号值加1。

如下这段代码是对信号量的基本使用：

// 设置最大线程数为4
    dispatch_semaphore_t sem = dispatch_semaphore_create(4);
    // 执行多个任务
    for (NSInteger i=0; i<10; i++) {
        
        // 开始一个任务时，如果sem的值大于0，会是sem的值减1，这里一开始初始化的sem值为4
        dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
        dispatch_queue_t queue = dispatch_queue_create("semophore_test", DISPATCH_QUEUE_CONCURRENT);
        dispatch_async(queue, ^{
            NSLog(@"currentThread==%ld==%@", i, [NSThread currentThread]);
            // 某个任务完成后，会空出当前线程，说明当前正在执行的最大线程数小于4，通过把信号量加1来告知系统
            dispatch_semaphore_signal(sem);
        });
    }

来分析一下上面这段代码：

首先我们先看一下，如果我们单纯的只想看下for循环的执行情况

  for (NSInteger i=0; i<10; i++) {
        NSLog(@"currentThread==%ld==%@", i, [NSThread currentThread]);
    }

输出结果

2019-06-19 23:46:43.956830+0800 Thread-Test[2856:124428] currentThread==0==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957016+0800 Thread-Test[2856:124428] currentThread==1==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957138+0800 Thread-Test[2856:124428] currentThread==2==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957237+0800 Thread-Test[2856:124428] currentThread==3==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957355+0800 Thread-Test[2856:124428] currentThread==4==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957464+0800 Thread-Test[2856:124428] currentThread==5==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957573+0800 Thread-Test[2856:124428] currentThread==6==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957670+0800 Thread-Test[2856:124428] currentThread==7==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957786+0800 Thread-Test[2856:124428] currentThread==8==<NSThread: 0x60000347a440>{number = 1, name = main}
2019-06-19 23:46:43.957891+0800 Thread-Test[2856:124428] currentThread==9==<NSThread: 0x60000347a440>{number = 1, name = main}

可以看出，for循环始终是在主线程里面执行的，而且是按顺序执行的，如果执行的次数非常大的时候，会有点阻塞主线程的。所以有的场景下我们不要求for循环的执行顺序，只想让for循环尽快的完成。

那么我们回到上面的通过信号量控制最大线程数的代码，其输出结果会是类似下面这样

2019-06-19 23:57:16.200986+0800 Thread-Test[2926:129038] currentThread==2==<NSThread: 0x6000037f15c0>{number = 5, name = (null)}
2019-06-19 23:57:16.200986+0800 Thread-Test[2926:129028] currentThread==0==<NSThread: 0x6000037f71c0>{number = 3, name = (null)}
2019-06-19 23:57:16.200994+0800 Thread-Test[2926:129039] currentThread==1==<NSThread: 0x6000037e8040>{number = 4, name = (null)}
2019-06-19 23:57:16.201015+0800 Thread-Test[2926:129027] currentThread==3==<NSThread: 0x6000037c5740>{number = 6, name = (null)}
2019-06-19 23:57:16.201179+0800 Thread-Test[2926:129038] currentThread==4==<NSThread: 0x6000037f15c0>{number = 5, name = (null)}
2019-06-19 23:57:16.201187+0800 Thread-Test[2926:129028] currentThread==5==<NSThread: 0x6000037f71c0>{number = 3, name = (null)}
2019-06-19 23:57:16.201209+0800 Thread-Test[2926:129027] currentThread==6==<NSThread: 0x6000037c5740>{number = 6, name = (null)}
2019-06-19 23:57:16.201194+0800 Thread-Test[2926:129039] currentThread==7==<NSThread: 0x6000037e8040>{number = 4, name = (null)}
2019-06-19 23:57:16.201318+0800 Thread-Test[2926:129038] currentThread==8==<NSThread: 0x6000037f15c0>{number = 5, name = (null)}
2019-06-19 23:57:16.201369+0800 Thread-Test[2926:129028] currentThread==9==<NSThread: 0x6000037f71c0>{number = 3, name = (null)}

对比两个输出结果就很明显可以看出问题了，加了线程控制后执行顺序没有了，而且看输出的number值可以发现，number始终保持在3、4、5、6，没有第五个数字了，也就是最大只能开辟4个子线程去执行这个for循环。

综上所述，可以通过设置信号量的初始值，来实现资源的管理，抑或可以通过设置信号量初始值为1来达到任务分组的效果，即任务1中的所有执行代码都会捆绑在一起，任务2、任务3中的任务也同样如此。
举例：

// 最多开启一个线程
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    dispatch_queue_t quene = dispatch_queue_create("semophore_test2", DISPATCH_QUEUE_CONCURRENT);
    
    //任务1
    dispatch_async(quene, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"task1");
        sleep(1);
        NSLog(@"task1 complete");
        dispatch_semaphore_signal(semaphore);
    });
    
    //任务2
    dispatch_async(quene, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"task2");
        sleep(1);
        NSLog(@"task2 complete");
        dispatch_semaphore_signal(semaphore);
    });
    
    //任务3
    dispatch_async(quene, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"task3");
        sleep(1);
        NSLog(@"task3 complete");
        dispatch_semaphore_signal(semaphore);
    });

其输出结果是task1一定是和task1 complete在一起前后执行，同理task2和task3也一样。

2019-06-20 00:10:31.261132+0800 Thread-Test[2965:133275] task1
2019-06-20 00:10:32.265053+0800 Thread-Test[2965:133275] task1 complete
2019-06-20 00:10:32.265339+0800 Thread-Test[2965:133274] task3
2019-06-20 00:10:33.270500+0800 Thread-Test[2965:133274] task3 complete
2019-06-20 00:10:33.270742+0800 Thread-Test[2965:133278] task2
2019-06-20 00:10:34.271697+0800 Thread-Test[2965:133278] task2 complete

1.7 快速迭代

上文提到for循环的执行默认是在主线程按顺序执行，而通过信号量设置最大线程数可以提高for循环的执行效率。这里的GCD也提供了一个快速迭代的方法dispatch_apply，目的就是开启多条线程，并发执行for循环中的任务。

 // 设置10个线程来执行for循环
    dispatch_queue_t applyQueue = dispatch_queue_create("apply_queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_apply(10, applyQueue, ^(size_t index) {
        NSLog(@"打印快速迭代调用---%zu", index);
    });

第一个参数，size_t iterations,任务需要执行的次数
第二个参数，dispatch_queue_t queue，提交的队列
第三个参数，block，要执行的任务
size_t index, block中每次任务执行的索引

1.8 主线程调用优化

之前看到过一个面试题，代码是这样的：

 NSLog(@"before main queue : %@",[NSThread currentThread]);

    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"current main queue：%@", [NSThread currentThread]);
    });
    
    NSLog(@"after main queue：%@", [NSThread currentThread]);

请问输出是怎样的？先思考1秒中，一开始我以为是before-current-after，但是打印出来却是这样的：

2019-06-20 00:27:31.412457+0800 Thread-Test[3029:139205] before main queue : <NSThread: 0x600003166940>{number = 1, name = main}
2019-06-20 00:27:31.412722+0800 Thread-Test[3029:139205] after main queue：<NSThread: 0x600003166940>{number = 1, name = main}
2019-06-20 00:27:31.425569+0800 Thread-Test[3029:139205] current main queue：<NSThread: 0x600003166940>{number = 1, name = main}

我们平时写代码的时候一个不留神，自以为就是按顺序执行的，然后就有可能出问题，而且自己还很难发现问题在哪里。在runloop的官方文档中有段对类似回主线程方法的说明。在调用performSelectorOnMainThread或者GCD中diapatch_get_main_queue()时，该方法要执行的任务会在下一个runloop中执行，在当前runloop相当于只会告诉系统我想执行这段block中的代码。

回到主线程方法说明

鉴于此，为了优化主线程调用，可以定义一个全局宏，需要用到dispatch_async(dispatch_get_main_queue() ^{})时，使用dispatch_get_main_safe(block)来替代。

#ifndef dispatch_main_async_safe
#define dispatch_main_async_safe(block)\
if (strcmp(dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL), dispatch_queue_get_label(dispatch_get_main_queue())) == 0) {\
block();\
} else {\
dispatch_async(dispatch_get_main_queue(), block);\
}
#endif

注：strcmp(s1, s2)是用来比较两个字符串的，从左至右逐个字符比较，如果全部相等返回0。

上面定义的dispatch_main_async_safe就是先判断当前线程是否在主线程，如果在主线程，就直接执行block中的任务。如果不在主线程，则切换到主线程后再下一个runloop执行block中的任务。

这篇就是我对GCD的一些理解，后面还有新的东西再慢慢加进来。

最近有遇到一个面试题，记录一下，如下代码的输出顺序是怎样的，在各条打印之前休眠多长时间（先思考一下）：

- (void)interviewTestCase1
{
    dispatch_async(dispatch_get_main_queue(), ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            sleep(2);
            NSLog(@"print1 - %@", [NSThread currentThread]);
        });
        
        NSLog(@"print2 - %@", [NSThread currentThread]);
        
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"print3 - %@", [NSThread currentThread]);
        });
    });
    sleep(1);
}

这个其实跟前面1.8中的有点类似，主要还是考虑了RunLoop的作用。

首先在当前RunLoop中，只会执行第一行的第一个dispatch_async代码，而Block中的代码会在下一个RunLoop中执行。
在下一个RunLoop中会执行第二个dispatch_async、打印print2和第三个dispatch_async，而第二个dispatch_async和第三个dispatch_async block中的代码要在下下个RunLoop中才会执行。
又由于主线程是串行的，所以会先执行完sleep(2)，再执行print1，最后执行print3。

所以如上代码的执行顺序就是print2-print1-print3，执行print1之前会等待2s。

那么再看看下面这段代码，如果换成是全局的子线程又会怎样？

 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            sleep(2);
            NSLog(@"print1 - %@", [NSThread currentThread]);
        });
        
        NSLog(@"print2 - %@", [NSThread currentThread]);
        
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"print3 - %@", [NSThread currentThread]);
        });
    });
    sleep(1);

RunLoop的解释是一样的，只是全局子线程是异步执行，所以print3会比print1要先执行。所以执行顺序是print2-print3-print1，并且执行print1之前会等待2s。

最后编辑于：2019.07.08 22:32:05

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