【IOS 知识点】多线程

基本概念

进程

可以理解成一个运行中的应用程序，是系统进行资源分配和调度的基本单位，是操作系统的基础，主要用来管理各种资源。

线程

是进程的基本执行单位，说白了就是具体干活的家伙，一个进程对应多个线程。

主线程

每个一应用程序有且只有一个主线程（相当于社团的话事人，渣Fit人），主要用来处理 UI，所有更新 UI 的操作都必须在主线程上执行，不要把耗时操作放在主线程，会卡界面。

子线程

除主线程之外其他一切系统或用户自己创建的线程，主要用来处理各种耗时操作。

所谓的多线程或者并发其实都是一种概念而已，计算机在同一时刻，一个 CPU（多核的系统那才是真正的并行）只能处理1条线程，但同一个 CPU 可以在多条线程之间快速的切换，只要切换的足够快，看上去就好像多条线程在同时执行。

线程的生命周期

线程的生命周期是：新建 - 就绪 - 运行 - 阻塞 - 死亡

新建

线程被实例化

就绪

线程被创建以后可以向他发送 start 消息，线程对象被加入到线程池中等待 CPU 调度。

运行

CPU 负责调度线程池中的线程。线程执行完成之前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员无法干预。

阻塞

当满足某些条件的时候，可以使用休眠或锁，阻塞线程的执行：sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。

死亡

正常死亡：线程执行完毕。非正常死亡：当满足某个条件后，在线程内部中止执行/在主线程中止子线程对象。

多线程的解决方案

iOS 有四种解决方案：pthread，NSThread，GCD， NSOperation。

pthread：运用C语言，是一套通用的API，可跨平台Unix/Linux/Windows。线程的生命周期由程序员管理。
NSThread：面向对象，可直接操作线程对象。线程的生命周期由程序员管理。
GCD：代替NSThread，可以充分利用设备的多核，自动管理线程生命周期。
NSOperation：底层是GCD，比GCD多了一些方法，更加面向对象，自动管理线程生命周期。

线程安全问题

当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题。就好比几个人在同一时修改同一个表格，造成数据的错乱。

解决多线程安全问题的方法有很多，最常用的有几种：

互斥锁（同步锁）

@synchronized(锁对象) {
    // 需要锁定的代码
}

最常用到的地方就是单例对象的初始化，判断的时候锁对象要存在，如果代码中只有一个地方需要加锁，大多都使用 self 作为锁对象，这样可以避免单独再创建一个锁对象。

加了互斥做的代码，当新线程访问时，如果发现其他线程正在执行锁定的代码，新线程就会进入休眠。

自旋锁

加了自旋锁，当新线程访问代码时，如果发现有其他线程正在锁定代码，新线程会用死循环的方式，一直等待锁定的代码执行完成。相当于不停尝试执行代码，比较消耗性能。

最常见的自旋锁就是属性修饰 atomic，任何用 atomic 修饰的属性本身就有一把自旋锁。

// 非原子属性，同一时间可以有很多线程读和写，非线程安全，不过效率很高
nonatomic 
// 原子属性(线程安全)，保证同一时间只有一个线程能够写入(但是同一个时间多个线程都可以取值)
// atomic 本身就有一把锁(自旋锁)
// 线程安全，但是需要消耗大量的资源
atomic

GCD的理解和使用

目前我们用的最多的多线程解决方案是 GCD（Grand Central Dispatch），他有很多的优点：GCD 会自动利用更多的 CPU 内核极大的提高运行效率；GCD 自动管理线程的生命周期（创建线程，调度任务，销毁线程等）和 ARC 一样，使用 GCD 程序员无需自己手动的去管理每个线程的生命周期；程序员只需要告诉 GCD 想要如何执行什么任务，不需要编写任何线程管理代码（这个简直不要太梦幻啊）。

那 GCD 到底是什么呢？

一言以蔽之：GCD 就是将想要执行的任务（可以把任务想象成 block）添加到不同的队列中（自己创建或使用全局并发队列），并且指定任务的执行方式（异步 dispatch_async，同步 dispatch_sync）。

**
**

这里说到了几个概念，下面我们一个一个细说。

任务

任务就是 Block，说的直白点就是将要在线程中执行的代码块，将这段代码用 block 封装好，然后添加到指定的队列中，并且指定不同的执行方式（同步执行和异步执行），最后等待 CPU 调度到不同的线程中执行。

队列

装载线程任务的数据结构（系统以先进先出的方式调度队列中的任务执行）。在GCD中有两种队列：串行队列 和并发队列。

既然是队列那一定是 FIFO，放到并行队列的任务，GCD 也是 FIFO 的取出来，但是和串行队列不同的是，它取出来一个就会放到别的线程中，然后再取出来一个又放到另一个线程中。由于取的动作很快，看起来，所有的任务都是一起执行的（所以叫并发）。

那么如何创建队列呢？

// 串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 并发队列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

最典型的有下面两种：

主队列 dispatch_get_main_queue

主队列是一个串行队列，负责在主线程上调度任务，如果在主线程上已经有任务正在执行，主队列会等到主线程空闲后再调度任务。通常是返回主线程更新UI的时候使用。

dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗时操作放在这里
        
        dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主线程进行UI操作
        });
    });

全局队列 dispatch_get_global_queue(0, 0)

全局队列是一个并发队列，为了让我们更方便的使用多线程。

// 全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 全局并发队列的优先级
#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    // 后台优先级
// iOS8开始使用服务质量，获取全局并发队列时，可以直接传0
dispatch_get_global_queue(0, 0);

派发

任务的派发方式有两种：

同步（sync）使用 dispatch_sync 来表示。
异步（async）使用 dispatch_async 来表示。

同步（sync）和异步（async）的本质区别在于会不会阻塞当前线程，直到 Block 中的任务执行完毕！

// 同步的在全局队列中执行任务
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
    // 任务放在这个block里
    NSLog(@"我是同步执行的任务");
});

// 异步的在全局队列中执行任务
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    // 任务放在这个block里
    NSLog(@"我是异步执行的任务");
});

如何使用

两种队列两种派发方式组合起来的话一共有4种：

串行同步

串行异步

并发同步

并发异步

串行同步：不开启新线程：****执行完一个任务，再执行下一个任务。

/** 串行同步 */
- (void)syncSerial {
    
    NSLog(@"\n\n**************串行同步***************\n\n");
    
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步1   %@", [NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步2   %@", [NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步3   %@", [NSThread currentThread]);
        }
    });
}

日志：

**************串行同步***************

串行同步1   <NSThread: 0x600001bac400>{number = 1, name = main}
串行同步1   <NSThread: 0x600001bac400>{number = 1, name = main}
串行同步1   <NSThread: 0x600001bac400>{number = 1, name = main}

串行同步2   <NSThread: 0x600001bac400>{number = 1, name = main}
串行同步2   <NSThread: 0x600001bac400>{number = 1, name = main}
串行同步2   <NSThread: 0x600001bac400>{number = 1, name = main}

串行同步3   <NSThread: 0x600001bac400>{number = 1, name = main}
串行同步3   <NSThread: 0x600001bac400>{number = 1, name = main}
串行同步3   <NSThread: 0x600001bac400>{number = 1, name = main}

串行异步：开启新线程：执行完一个任务，再执行下一个任务。

/** 串行异步 */
- (void)asyncSerial {
    
    NSLog(@"\n\n**************串行异步***************\n\n");
    
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
    
    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步1   %@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步2   %@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步3   %@", [NSThread currentThread]);
        }
    });
}

日志：

**************串行异步***************

串行异步1   <NSThread: 0x600001d313c0>{number = 6, name = (null)}
串行异步1   <NSThread: 0x600001d313c0>{number = 6, name = (null)}
串行异步1   <NSThread: 0x600001d313c0>{number = 6, name = (null)}

串行异步2   <NSThread: 0x600001d313c0>{number = 6, name = (null)}
串行异步2   <NSThread: 0x600001d313c0>{number = 6, name = (null)}
串行异步2   <NSThread: 0x600001d313c0>{number = 6, name = (null)}

串行异步3   <NSThread: 0x600001d313c0>{number = 6, name = (null)}
串行异步3   <NSThread: 0x600001d313c0>{number = 6, name = (null)}
串行异步3   <NSThread: 0x600001d313c0>{number = 6, name = (null)}

并发同步：不会开启新线程：执行完一个任务，再执行下一个任务。

/** 并发同步 */
- (void)syncConcurrent {
    
    NSLog(@"\n\n**************并发同步***************\n\n");
    
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步1   %@", [NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步2   %@", [NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发同步3   %@", [NSThread currentThread]);
        }
    });
}

日志：

**************并发同步***************

并发同步1   <NSThread: 0x6000000381c0>{number = 1, name = main}
并发同步1   <NSThread: 0x6000000381c0>{number = 1, name = main}
并发同步1   <NSThread: 0x6000000381c0>{number = 1, name = main}

并发同步2   <NSThread: 0x6000000381c0>{number = 1, name = main}
并发同步2   <NSThread: 0x6000000381c0>{number = 1, name = main}
并发同步2   <NSThread: 0x6000000381c0>{number = 1, name = main}

并发同步3   <NSThread: 0x6000000381c0>{number = 1, name = main}
并发同步3   <NSThread: 0x6000000381c0>{number = 1, name = main}
并发同步3   <NSThread: 0x6000000381c0>{number = 1, name = main}

并发异步：开启多线程：任务交替执行。

/** 并发异步 */
- (void)asyncConcurrent {
    
    NSLog(@"\n\n**************并发异步***************\n\n");
    
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步1   %@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步2   %@", [NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并发异步3   %@", [NSThread currentThread]);
        }
    });
}

日志；

**************并发异步***************

并发异步2   <NSThread: 0x600000184780>{number = 6, name = (null)}
并发异步1   <NSThread: 0x6000001c5dc0>{number = 4, name = (null)}
并发异步3   <NSThread: 0x6000001941c0>{number = 5, name = (null)}
并发异步1   <NSThread: 0x6000001c5dc0>{number = 4, name = (null)}
并发异步2   <NSThread: 0x600000184780>{number = 6, name = (null)}
并发异步3   <NSThread: 0x6000001941c0>{number = 5, name = (null)}
并发异步1   <NSThread: 0x6000001c5dc0>{number = 4, name = (null)}
并发异步2   <NSThread: 0x600000184780>{number = 6, name = (null)}
并发异步3   <NSThread: 0x6000001941c0>{number = 5, name = (null)}

这里需要注意的是一种特殊的串行队列，也就是主队列：dispatch_get_main_queue()

在主队列上无论是同步还是异步的派发方式，都不会开启新的线程，如果在主队列上同步的执行任务会造成死锁，原因很简单，主队列是串行队列，里面的任务会立马执行，但是任务执行的时候必须等待主队列中调用该任务的代码执行完毕，这样互相等待造成了死锁。

线程之间的通讯

最简单的就是把耗时操作放在全局队列的子线程中执行，执行完后通知主队列，在主线程上进行 UI 刷新。

还有一种比较常见的就是栅栏：当任务需要异步进行，但是这些任务需要分成两组来执行，第一组完成之后才能进行第二组的操作。这时候就用了到 GCD 的栅栏方法 dispatch_barrier_async()。

- (void)barrierGCD {
    
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    // 异步执行任务一
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步1   %@", [NSThread currentThread]);
        }
    });
    // 异步执行任务二
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步2   %@", [NSThread currentThread]);
        }
    });
    // 在两组任务之间添加一个栅栏
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 并发异步执行，但是34一定在12后面 *********");
    });
    // 异步执行任务三
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步3   %@", [NSThread currentThread]);
        }
    });
    // 异步执行任务四
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：并发异步4   %@", [NSThread currentThread]);
        }
    });
}

日志：

栅栏：并发异步1   <NSThread: 0x60000061c3c0>{number = 5, name = (null)}
栅栏：并发异步2   <NSThread: 0x60000060a380>{number = 6, name = (null)}
栅栏：并发异步1   <NSThread: 0x60000061c3c0>{number = 5, name = (null)}
栅栏：并发异步2   <NSThread: 0x60000060a380>{number = 6, name = (null)}
栅栏：并发异步1   <NSThread: 0x60000061c3c0>{number = 5, name = (null)}
栅栏：并发异步2   <NSThread: 0x60000060a380>{number = 6, name = (null)}
------------barrier------------<NSThread: 0x60000060a380>{number = 6, name = (null)}
******* 并发异步执行，但是34一定在12后面 *********
栅栏：并发异步3   <NSThread: 0x60000060a380>{number = 6, name = (null)}
栅栏：并发异步4   <NSThread: 0x60000061c3c0>{number = 5, name = (null)}
栅栏：并发异步3   <NSThread: 0x60000060a380>{number = 6, name = (null)}
栅栏：并发异步4   <NSThread: 0x60000061c3c0>{number = 5, name = (null)}
栅栏：并发异步3   <NSThread: 0x60000060a380>{number = 6, name = (null)}
栅栏：并发异步4   <NSThread: 0x60000061c3c0>{number = 5, name = (null)}

从上面代码的打印可以知道，开启了多线程，所有任务都是并发异步进行。但是第一组完成之后，才会进行第二组的执行。

延时执行

等待一段时间后执行某个任务，这个地球人都知道。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 5秒后异步执行
    NSLog(@"我已经等待了5秒！");
});

代码只执行一次

写过单例的同学都知道。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"程序运行过程中我只执行了一次！");
});

快速迭代

GCD 有一个快速迭代的方法 dispatch_apply，可以同时遍历多个数字，非常方便。

- (void)applyGCD {
    
    NSLog(@"\n\n************** GCD快速迭代 ***************\n\n");
    
    // 并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    // dispatch_apply可以同时（并发的）遍历多个数字
    dispatch_apply(7, queue, ^(size_t index) {
        NSLog(@"dispatch_apply：%zd======%@", index, [NSThread currentThread]);
    });
}

队列组

异步执行多个耗时操作，当这些操作都完成之后再回到主线程进行操作，就可以用到队列组了。最常见的应用就是下载九宫格图片，所有图片都下载完成后再通知 UI 进行布局刷新、
队列组有下面几个特点：

所有的任务会并发的执行（不按序）。
所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。
使用 dispatch_group_notify 函数来监听上面的任务是否完成，如果全部完成，就会调用这个方法。

- (void)testGCDGroup {
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：耗时操作A完成！");
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：耗时操作B完成！");
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：耗时操作C完成！");
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：耗时操作D完成！");
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"队列组：前面的耗时操作都完成了，回到主线程进行相关操作");
    });
}

日志：

队列组：耗时操作A完成！
队列组：耗时操作C完成！
队列组：耗时操作D完成！
队列组：耗时操作B完成！
队列组：前面的耗时操作都完成了，回到主线程进行相关操作

Dispatch Source

除了上面说的代码的平行执行能力，GCD 还提供高度集成的事件控制系统。可以设置句柄来响应文件描述符、mach ports（Mach port 用于 OS X上的进程间通讯）、进程、计时器、信号、用户生成事件。这些句柄通过GCD来并发执行。是不是有点绕？简单来说，dispatch source 是一个监视某些类型事件的对象，当这些事件发生时，它自动将一个任务（block）放入到一个队列（dispatch queue）中执行。

实际上，使用的 dispatch source 而不使用 dispatch_async 的唯一原因就是利用联结的优势。

- (void)testDispatchSource {
    // 创建source，以ADD的方式进行累加，OR的话是对结果进行二进制或运算
    dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
    
    // 事件触发后执行的句柄
    dispatch_source_set_event_handler(source, ^{
        NSLog(@"监听函数：%lu", dispatch_source_get_data(source));
        NSLog(@"ThreadName：%@", [NSThread currentThread]);
    });
    
    // 开启source监听（就绪）
    dispatch_resume(source);
    
    dispatch_queue_t myqueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(myqueue, ^ {
        
        for(int i = 1; i <= 4; i ++){
            
            NSLog(@"~~~~~~~~~~~~~~%d", i);
            // 触发事件，向source发送事件，这里i不能为0，否则触发不了事件
            dispatch_source_merge_data(source,i);
            
            // 当Interval的事件越长，则每次的句柄都会触发
            //[NSThread sleepForTimeInterval:0.0001];
        }
    });
}

日志：

~~~~~~~~~~~~~~1
~~~~~~~~~~~~~~2
~~~~~~~~~~~~~~3
~~~~~~~~~~~~~~4
监听函数：10
ThreadName：<NSThread: 0x600002868900>{number = 1, name = main}

从上面的日志中可以看出，虽然 dispatch_source_merge_data 在 for 循环里面被调用了4次，但实际 handler（句柄）只收到了一次通知，但是这唯一收到的一次通知是四次 for 循环里面通知调用结果的联结：1+2+3+4 == 10。

这里其实有一个非常好的应用，就是在应用程序中设计一个界面进度条来反映各种异步任务的完成进度：如果主线程忙于其他工作，或者工作单元完成速度很快，那么完成事件会被联结起来，导致进度条只在主线程变得可用时才被更新，并且一次将积累的改变更新至 UI（不用每次有一点变化就刷新 UI）。

实际应用

在子线程中操作剪贴板

如果需要进行大文件或者多文件的IO操作，禁止主线程使用，必须进行异步处理，因此对剪贴板的读取必须要放在异步线程处理（iOS13以后mac和iOS可以通过剪贴板共享大量的数据）。

最新Mac和iOS里的剪贴板共享功能会导致有可能需要读取大量的内容，导致读取线程被长时间阻塞

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
   UIPasteboard *pasteboard = [UIPasteboard generalPasteboard]; 
   if (pasteboard.string.length > 0) {//这个方法会阻塞线程
      NSString *text = [pasteboard.string copy];
      [pasteboard setValue:@"" forPasteboardType:UIPasteboardNameGeneral];
      if (text == nil || [text isEqualToString:@""]) {
          return ;
      }
      dispatch_async(dispatch_get_main_queue(), ^{
          [self processShareCode:text];
      });
   }
});

使用信号量控制线程并发数

- (void)mutiThreadControl {
    
    // 创建了一个初使值为10的semaphore（也就是并发数控制在10）
    // 每一次for循环都会创建一个新的线程，线程结束的时候会发送信号（V操作），线程创建之前会等待信号（P操作）
    // 当同时创建了10个线程之后，for循环就会阻塞，等待有线程结束之后会增加信号才能继续执行创建新的线程
    // 如此就形成了对并发的控制（本质就是一个并发数为10的线程队列）

    dispatch_group_t group = dispatch_group_create();
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(10);
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
    for(int i = 0; i < 100; i++) {
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        dispatch_group_async(group, queue, ^{
            NSLog(@"%i",i);
            sleep(2);
            dispatch_semaphore_signal(semaphore);
        });
    }
    // 一直等到和这个dispatch_group关联的所有block（任务）都执行完毕后才会返回（0表示成功，非0表示出错）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"end");
}

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