iOS-内存管理6-autorelease

一. 转成C++代码

我们都知道，在MRC中，当对象调用autorelease后，这个对象会在它所在的自动释放池结束后调用release方法，如下代码：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        MJPerson *person = [[[MJPerson alloc] init] autorelease];
    }
    return 0;
}

person指针指向的对象会在{}结束后调用release方法，但是它底层是怎么实现的呢？

将上面代码转成C++代码，如下：

int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        MJPerson *person = ((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)((MJPerson *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("MJPerson"), sel_registerName("alloc")), sel_registerName("init")), sel_registerName("autorelease"));
    }
    return 0;
}

上面代码，相信应该很容易理解，剔除没用的，如下：

/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
......
}

上面定义了一个__autoreleasepool局部变量，搜索__AtAutoreleasePool定义，发现是个结构体，如下：

//C++的结构体和类很像，结构体中也可以定义函数，你可以认为它就是个类
struct __AtAutoreleasePool {

  //构造函数，在创建结构体的时候调用
  __AtAutoreleasePool() {
      atautoreleasepoolobj = objc_autoreleasePoolPush();
  }

  //析构函数，在结构体销毁的时候调用
  ~__AtAutoreleasePool() {
      objc_autoreleasePoolPop(atautoreleasepoolobj);
  }
    
  void * atautoreleasepoolobj;
};

根据上面代码，所以文章开头的代码其实就是这三行：

//构造函数
atautoreleasepoolobj = objc_autoreleasePoolPush();
//对象调用了autorelease
MJPerson *person = [[[MJPerson alloc] init] autorelease];
//析构函数
objc_autoreleasePoolPop(atautoreleasepoolobj);

现在我们知道了，autoreleasepool会在刚开始调用Push，结束调用Pop，想要知道这两个函数内部做了什么还要进去看看。

在objc4里面搜索这两个函数：

void *
objc_autoreleasePoolPush(void)
{
    //调用C++类的push()方法
    return AutoreleasePoolPage::push();
}

void
objc_autoreleasePoolPop(void *ctxt)
{
    //调用C++类的pop()方法
    AutoreleasePoolPage::pop(ctxt);
}

可以发现，分别是调用AutoreleasePoolPage类的push()和pop()方法。

小总结：

  1. 自动释放池的主要底层数据结构是：__AtAutoreleasePool结构体、AutoreleasePoolPage类
  2. 调用了autorelease的对象最终都是通过AutoreleasePoolPage对象来管理的

二. AutoreleasePoolPage类

进入AutoreleasePoolPage类，简化后留下有用的东西：

class AutoreleasePoolPage 
{
......
    magic_t const magic;
    id *next;
    pthread_t const thread; //专属的线程
    AutoreleasePoolPage * const parent;
    AutoreleasePoolPage *child;
    uint32_t const depth;
    uint32_t hiwat;
......
}

那么这些成员有什么用？

先看结论：

  1. 每个AutoreleasePoolPage对象占用4096字节内存，除了用来存放它内部的成员变量，剩下的空间用来存放调用了autorelease方法的对象的地址
  2. 所有的AutoreleasePoolPage对象通过双向链表的形式连接在一起

什么是双向链表？
就是A链表可以访问B链表，B链表也可以访问A链表。

为什么要设计成双向链表？
因为一个AutoreleasePoolPage对象只占用4096字节内存，如果存满了，就会创建一个新的AutoreleasePoolPage对象，然后这些AutoreleasePoolPage对象之间通过通过双向链表的形式连接在一起，如下图：

双向链表.png
  1. 0x2000 - 0x1000 = 0x1000，转成10进制就是4096字节，一个AutoreleasePoolPage对象占用4096字节。
  2. 0x1038 - 0x1000 = 0x0038，转成10进制就是56字节，AutoreleasePoolPage对象内部的七个成员，每个成员占用8字节，所以一共占用56字节。
  3. 4096 - 56 = 4040，所以剩下的4040字节用来存放调用了autorelease方法的对象的地址，如果这个AutoreleasePoolPage对象里面不够存了，就会创建一个新的AutoreleasePoolPage对象。

上面的begin()函数是什么？同样在NSObject.mm里面找到源码：

id * begin() {
    return (id *) ((uint8_t *)this+sizeof(*this));
}

id * end() {
    return (id *) ((uint8_t *)this+SIZE);
}

对于begin()，就是this指针（就是自己的地址，如上面的0x1000）加上它自己有多大（就是他内部的七个成员变量的大小：56），返回的是一个地址，这个地址就是从什么地方开始存储调用了autorelease方法的对象的地址。

同理，对于end()，找到SIZE源码：

static size_t const SIZE = PAGE_MAX_SIZE;
#define PAGE_MAX_SIZE           PAGE_SIZE
#define PAGE_SIZE               I386_PGBYTES
#define I386_PGBYTES            4096

可以发现，SIZE就是4096字节，所以对于end()，就是自己地址加上4096，就得到结束的地方的地址。

parent指针指向上一个AutoreleasePoolPage对象的地址值，child指针指向下一个AutoreleasePoolPage对象的地址值。双向链表就是通过parent指针和child指针联系在一起的。

三. push()和pop()

那么push()和pop()函数里面究竟做了什么呢？

1. push()

调用push()方法会将一个POOL_BOUNDARY入栈，并且返回其存放的内存地址，那么这句话是什么意思呢？

在objc4搜索POOL_BOUNDARY：

define POOL_BOUNDARY nil //就相当于0

看下图：

POOL_BOUNDARY.png

就是将0这个值存放到0x1038的位置，然后把0x1038这个地址值返回，如下代码返回的就是0x1038。

atautoreleasepoolobj = objc_autoreleasePoolPush();
// atautoreleasepoolobj = 0x1038

接下来就开始执行代码:

MJPerson *person = [[[MJPerson alloc] init] autorelease];

当发现有一个对象调用了autorelease，就把这个对象的地址值接着0x1038往下存，当发现这个AutoreleasePoolPage对象不够存的时候，就会创建一个新的，然后用它的child指针指向这个新的AutoreleasePoolPage对象，然后用新的AutoreleasePoolPage对象存储，如下，当autoreleasepool里面有1000个对象的时候：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        for (int i = 0; i < 1000; i++) {
            MJPerson *person = [[[MJPerson alloc] init] autorelease];
    } 
}

那么这1000个对象的地址在AutoreleasePoolPage对象里面存储的结构为：

1000个对象

当代码都执行完后，就会调用objc_autoreleasePoolPop()函数

2. pop()

调用pop()方法时传入一个POOL_BOUNDARY的内存地址（也就是上面说的0x1038），会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY。

上面的next是什么呢？
id *next指向了下一个能存放autorelease对象地址的区域。
比如，一开始next指向0x1038，当调用push之后把POOL_BOUNDARY入栈，这时候next就指向0x1038下一格的位置，如果这时候有一个对象的地址存储到了AutoreleasePoolPage对象里面，那么next就指向0x1038下下一格的位置，以此类推。

四. autoreleasepool嵌套

如下代码：

01 int main(int argc, const char * argv[]) {
02     @autoreleasepool { //  r1 = push()
03         MJPerson *p1 = [[[MJPerson alloc] init] autorelease];
04         MJPerson *p2 = [[[MJPerson alloc] init] autorelease];
05
06         @autoreleasepool { // r2 = push()
07             MJPerson *p3 = [[[MJPerson alloc] init] autorelease];
08
09             @autoreleasepool { // r3 = push()
10                 MJPerson *p4 = [[[MJPerson alloc] init] autorelease];
11
12             } // pop(r3)
13         } // pop(r2)
14     } // pop(r1)
15     return 0;
16 }

第02行将POOL_BOUNDARY (r1)存进去
第03、04行分别将p1、p2存进去
第06行将POOL_BOUNDARY (r2)存进去
第07行将p3存进去
第09行将POOL_BOUNDARY (r3)存进去
第10行将p4存进去
第12行拿到r3，从最后一个进栈的对象(p4)开始release，一直到r3
第13行拿到r2，从最后一个进栈的对象(p3)开始release，一直到r2
第14行拿到r1，从最后一个进栈的对象(p2、p1)开始release，一直到r1

结合下图，更容易理解：

autoreleasepool嵌套

注意：

  1. 上面说的入栈并不是内存中的堆、栈那个栈，而是数据结构的那种栈。
  2. 我们知道栈是先进后出，比如上面的存储地址的过程，push进来和pop出去就达到了先进后出的效果。

使用打印验证：

以前说过，可以通过以下私有函数来查看自动释放池的情况：

extern void _objc_autoreleasePoolPrint(void);

_objc_autoreleasePoolPrint函数是私有的，使用extern声明这个函数，就可以直接调用了，如下：

extern void _objc_autoreleasePoolPrint(void);

int main(int argc, const char * argv[]) {
    @autoreleasepool { //  r1 = push()
        MJPerson *p1 = [[[MJPerson alloc] init] autorelease];
        MJPerson *p2 = [[[MJPerson alloc] init] autorelease];
        
        @autoreleasepool { // r2 = push()
            for (int i = 0; i < 600; i++) {
                MJPerson *p3 = [[[MJPerson alloc] init] autorelease];
            }
            
            @autoreleasepool { // r3 = push()
                MJPerson *p4 = [[[MJPerson alloc] init] autorelease];
                _objc_autoreleasePoolPrint(); //查看自动释放池的情况
 
            } // pop(r3)
        } // pop(r2)
    } // pop(r1)
    return 0;
}

打印：

objc[65684]: ##############
objc[65684]: AUTORELEASE POOLS for thread 0x1000aa5c0              //对应的线程
objc[65684]: 606 releases pending.                                 //一共存了606个
objc[65684]: [0x101803000]  ................  PAGE (full)  (cold)  //第一页 cold
objc[65684]: [0x101803038]  ################  POOL 0x101803038     //POOL_BOUNDARY (r1)
objc[65684]: [0x101803040]       0x100541000  MJPerson
objc[65684]: [0x101803048]       0x100541420  MJPerson
objc[65684]: [0x101803050]  ################  POOL 0x101803050     //POOL_BOUNDARY (r2)
objc[65684]: [0x101803058]       0x100540e10  MJPerson
objc[65684]: [0x101803ff0]       0x10053bd10  MJPerson
......省略
objc[65684]: [0x101802ef0]       0x10053bd20  MJPerson
objc[65684]: [0x101803ff8]       0x10053bd20  MJPerson
objc[65684]: [0x100806000]  ................  PAGE  (hot)          //创建一个新的AutoreleasePoolPage对象  第二页 hot
objc[65684]: [0x100806038]       0x10053bd30  MJPerson
objc[65684]: [0x100806040]       0x10053bd40  MJPerson
......省略
objc[65684]: [0x101803048]       0x100541420  MJPerson
objc[65684]: [0x100806348]       0x10053c350  MJPerson
objc[65684]: [0x100806350]  ################  POOL 0x100806350     //POOL_BOUNDARY (r3)
objc[65684]: [0x100806358]       0x10053c360  MJPerson
objc[65684]: ##############

一共存了606个，其中603个对象，3个POOL_BOUNDARY。从上面打印也可以看出，当AutoreleasePoolPage对象存不下时会创建一个新的AutoreleasePoolPage对象。其中第一页是cold是冷的意思，第二页是hot是热的意思，hot页是当前页的意思，以后release的时候就会从hot页开始。

五. 查看push()、autorelease、pop()源码

1. 先看push()

现在我们看push()和pop()函数的源码应该就很容易理解了：

static inline void *push() 
{
    id *dest;
    if (DebugPoolAllocation) {
        //没有page对象就new一个，并将POOL_BOUNDARY传进去
        dest = autoreleaseNewPage(POOL_BOUNDARY); 
    } else {
        //有page对象，直接将POOL_BOUNDARY传进去
        dest = autoreleaseFast(POOL_BOUNDARY);
    }
    assert(dest == EMPTY_POOL_PLACEHOLDER || *dest == POOL_BOUNDARY);
    return dest;
}

进入autoreleaseFast函数：

static inline id *autoreleaseFast(id obj)
{
    AutoreleasePoolPage *page = hotPage();
    if (page && !page->full()) { //如果有page并且没有满
        return page->add(obj); //将POOL_BOUNDARY入栈
    } else if (page) { //如果有page(满了)
        return autoreleaseFullPage(obj, page);
    } else { //如果没page
        return autoreleaseNoPage(obj);
    }
}

通过上面两段push()的源代码可知，如果有page就直接将POOL_BOUNDARY入栈，如果没有page，就创建page之后再将POOL_BOUNDARY入栈，验证了我们上面说的。

2. 再看autorelease

在NSObjec.mm -> autorelease -> rootAutorelease -> rootAutorelease2，进入rootAutorelease2函数：

objc_object::rootAutorelease2()
{
    assert(!isTaggedPointer());
    //哪一个对象调用autorelease就将哪一个对象传进去，并调用AutoreleasePoolPage的autorelease方法
    return AutoreleasePoolPage::autorelease((id)this);
}

可以看出，哪一个对象调用autorelease就将哪一个对象传进去，并调用AutoreleasePoolPage的autorelease方法，进入autorelease方法：

static inline id autorelease(id obj)
{
    assert(obj);
    assert(!obj->isTaggedPointer());
    id *dest __unused = autoreleaseFast(obj); //将对象地址值add到AutoreleasePoolPage里面去
    assert(!dest  ||  dest == EMPTY_POOL_PLACEHOLDER  ||  *dest == obj);
    return obj;
}

可以发现，这里也调用了autoreleaseFast函数，autoreleaseFast函数的实现上面有，就是将对象地址值add到AutoreleasePoolPage里面去。

3. 再看pop()

static inline void pop(void *token)
{
    AutoreleasePoolPage *page;
    id *stop;
    
    ......省略
    
    page = pageForPointer(token);
    stop = (id *)token; //token就是POOL_BOUNDARY的地址值，将token赋值给stop
    if (*stop != POOL_BOUNDARY) {
        if (stop == page->begin()  &&  !page->parent) {
        } else {
            return badPop(token);
        }
    }
    
    if (PrintPoolHiwat) printHiwat();
    
    page->releaseUntil(stop); //释放对象，直到遇到stop为止
    
    ......省略
}

省略掉其他代码，只看上面的注释。
pop()函数需要传入一个参数，这个参数就是POOL_BOUNDARY的地址值，最后调用releaseUntil释放对象，直到遇到stop为止，进入releaseUntil函数：

void releaseUntil(id *stop) 
{
    //使用while循环不断取出page里面的东西
    while (this->next != stop) {
        AutoreleasePoolPage *page = hotPage();

        while (page->empty()) {
            page = page->parent;
            setHotPage(page);
        }

        page->unprotect();
        id obj = *--page->next;
        memset((void*)page->next, SCRIBBLE, sizeof(*page->next));
        page->protect();

        //将取出的东西release掉
        if (obj != POOL_BOUNDARY) {
            objc_release(obj);
        }
}

上面代码使用while循环不断取出page里面存储的对象，然后将取出的对象release掉，和我们上面讲的一样。

六. 总结

下面代码：

@autoreleasepool {
    MJPerson *person = [[[MJPerson alloc] init] autorelease];
}

底层就是下面三行：

//构造函数
atautoreleasepoolobj = objc_autoreleasePoolPush();
//对象调用了autorelease
MJPerson *person = [[[MJPerson alloc] init] autorelease];
//析构函数
objc_autoreleasePoolPop(atautoreleasepoolobj);
  1. 自动释放池的主要底层数据结构是：__AtAutoreleasePool结构体、AutoreleasePoolPage类，调用了autorelease的对象最终都是通过AutoreleasePoolPage对象来管理的。
  2. 每个AutoreleasePoolPage对象占用4096字节内存，除了用来存放它内部的成员变量，剩下的空间用来存放调用了autorelease方法的对象的地址，所有的AutoreleasePoolPage对象通过双向链表的形式连接在一起。
  3. 调用push()方法会将一个POOL_BOUNDARY入栈，并且返回其存放的内存地址。
  4. 当发现有一个对象调用了autorelease，就把这个对象的地址值接着POOL_BOUNDARY往下存，当发现这个AutoreleasePoolPage对象不够存的时候，就会创建一个新的，然后用它的child指针指向这个新的AutoreleasePoolPage对象，然后用新的AutoreleasePoolPage对象存储。
  5. 调用pop()方法时传入一个POOL_BOUNDARY的内存地址，会从最后一个入栈的对象开始发送release消息，直到遇到这个POOL_BOUNDARY。

七. RunLoop与autorelease

1. 面试题1

调用autorelease的对象在什么时机会被调用release？

① 如果有@autoreleasepool{}

创建一个新项目，修改为MRC，代码如下：

- (void)viewDidLoad {
    [super viewDidLoad];

    NSLog(@"111");
    @autoreleasepool {
        MJPerson *person = [[[MJPerson alloc] init] autorelease];
    }
    NSLog(@"333");
}

打印：

111
-[MJPerson dealloc]
333

根据我们上面学的知识，很好理解，因为使用了autoreleasepool，所以autoreleasepool里面调用了autorelease方法的对象会在{}结束之后释放，所以才是上面打印。

② 如果没写@autoreleasepool{}

那如果没写@autoreleasepool呢？

- (void)viewDidLoad {
    [super viewDidLoad];

    NSLog(@"111");
    MJPerson *person = [[[MJPerson alloc] init] autorelease];
    NSLog(@"333");
}

打印：

111
333
-[MJPerson dealloc]

你可能会想，上面的代码没autoreleasepool，但是整个程序的main函数里面不是有一个autoreleasepool吗，那上面那些代码是不是被main函数的autoreleasepool管理呢？

int main(int argc, char * argv[]) {
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

显然不是的，如果上面的代码是被main函数的autoreleasepool管理的，那么程序退出之前这个autoreleasepool是不会结束的，对象就不会被释放，但是上面打印的结果表明对象的确被释放了，说明上面那些代码不是被main函数的autoreleasepool管理的。

可能你还会想，那person对象会不会是在viewDidLoad方法调用完毕再释放的呢？

这个更好验证：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    NSLog(@"111");
    MJPerson *person = [[[MJPerson alloc] init] autorelease];
    NSLog(@"333");

    NSLog(@"%s", __func__);
}

- (void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    NSLog(@"%s", __func__);
}

- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];
    NSLog(@"%s", __func__);
}

打印：

111
333
-[ViewController viewDidLoad]
-[ViewController viewWillAppear:]
-[MJPerson dealloc]
-[ViewController viewDidAppear:]

可以发现，是在viewWillAppear之后才释放的，可能你会越来越迷糊，那person对象究竟是在什么时候被释放呢？

其实这个问题和RunLoop有关：

打印NSLog(@"%@",[NSRunLoop mainRunLoop])，打印结果比较多，抽取我们需要的两个监听器，如下：

observers = (
"<CFRunLoopObserver 0x600002314be0 [0x10aac2ae8]>{valid = Yes, activities = 0x1, repeats = Yes, order = -2147483647, callout = _wrapRunLoopWithAutoreleasePoolHandler (0x10d690c9d), context = <CFArray 0x600001c5cf00 [0x10aac2ae8]>{type = mutable-small, count = 1, values = (\n\t0 : <0x7ffc78003058>\n)}}",
......省略
"<CFRunLoopObserver 0x600002314c80 [0x10aac2ae8]>{valid = Yes, activities = 0xa0, repeats = Yes, order = 2147483647, callout = _wrapRunLoopWithAutoreleasePoolHandler (0x10d690c9d), context = <CFArray 0x600001c5cf00 [0x10aac2ae8]>{type = mutable-small, count = 1, values = (\n\t0 : <0x7ffc78003058>\n)}}"
),

RunLoop的状态如下，下面会用到

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) {
kCFRunLoopEntry = (1UL << 0), 1
kCFRunLoopBeforeTimers = (1UL << 1), 2
kCFRunLoopBeforeSources = (1UL << 2), 4
kCFRunLoopBeforeWaiting = (1UL << 5), 32
kCFRunLoopAfterWaiting = (1UL << 6), 64
kCFRunLoopExit = (1UL << 7), 128
kCFRunLoopAllActivities = 0x0FFFFFFFU
};

观察打印结果里面的activities
第一个observer的activities = 0x1，就是1，说明第一个observer监听kCFRunLoopEntry状态。
第一个observer的activities = 0xa0，转成十进制是160，正好是32+128，说明第二个observer监听kCFRunLoopBeforeWaiting和kCFRunLoopExit状态。

看着MJ老师的图，我们进行总结：

RunLoop的运行逻辑.png

总结：

  1. iOS在主线程的Runloop中注册了2个Observer，当第1个Observer监听到了进入状态(kCFRunLoopEntry)，就会调用objc_autoreleasePoolPush()
  2. 当第2个Observer监听到了即将休眠状态(kCFRunLoopBeforeWaiting)就会调用objc_autoreleasePoolPop()和objc_autoreleasePoolPush()
  3. 当第2个Observer监听到了即将退出状态(kCFRunLoopBeforeExit)就会调用objc_autoreleasePoolPop()

这样，整个RunLoop运行循环中push和pop就能完全对得上。

现在就能回答刚才的问题了，如果没写@autoreleasepool{}，由于整个程序没有退出，autoreleasepool里面调用了autorelease方法的对象会在RunLoop休眠之前被释放。

- (void)viewDidLoad {
    [super viewDidLoad];
    // 这个Person什么时候调用release，是由RunLoop来控制的
    // 它可能是在某次RunLoop循环中，RunLoop休眠之前调用了release
    MJPerson *person = [[[MJPerson alloc] init] autorelease];
}

再次观察上面的打印信息：

111
333
-[ViewController viewDidLoad]
-[ViewController viewWillAppear:]
-[MJPerson dealloc]
-[ViewController viewDidAppear:]

既然person对象会在RunLoop休眠之前被释放，那么可以看出viewDidLoad和viewWillAppear处在同一次运行循环中（因为一次休眠到下一次休眠是一个循环）。

2. 面试题2

ARC中，方法里有局部对象，出了方法后会立即释放吗？

这个问题，我们猜想有两种可能：

  1. 如果ARC生成的代码是直接在方法完成之前给对象调用了一次[person release]，那么对象就会在方法结束之后立马释放。
  2. 如果ARC生成的代码是直接在对象后面加autorelease，那么对象就会在RunLoop休眠之前被释放。

我们实验一下，运行如下代码：

- (void)viewDidLoad {
    [super viewDidLoad];

    MJPerson *person = [[MJPerson alloc] init];

    NSLog(@"%s", __func__);
    // ARC中就相当于在这里生成一行 [person release];
}

- (void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    
    NSLog(@"%s", __func__);
}

- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];
    
    NSLog(@"%s", __func__);
}

打印：

-[ViewController viewDidLoad]
-[MJPerson dealloc]
-[ViewController viewWillAppear:]
-[ViewController viewDidAppear:]

可以发现，viewDidLoad执行完后对象立马就被释放了，说明ARC中，方法里有局部对象，出了方法后会立即释放，因为就相当于在方法的最后加一行release代码。

Demo地址：autorelease

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