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。

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

推荐阅读更多精彩内容