OC-release的内部实现

一直知道release就是计数--，之前也大概看了下代码，了解到内部实现没这么简单，近期就花了点时间了解了一下这一块的实现

1. 几个小知识

1.1 TaggedPointer

苹果采用64位处理器后, 为了节省内存和提高执行效率，苹果提出了Tagged Pointer的概念。对于64位程序，引入Tagged Pointer后，一些基础的数据对象能减少一半的内存占用，以及3倍的访问速度提升，100倍的创建、销毁速度提升

更多细节可参考深入理解Tagged Pointer
1.2 Pointer isa

对象的isa不包含额外的信息，跟Nonpointer isa刚好相反

1.3 Nonpointer isa

对象的isa不仅包含类的信息，同时还使用了一些位来存储一些额外的信息

查看objc源码中的定义

union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };
#endif
};

展开ISA_BITFIELD

// arm64
#   define ISA_BITFIELD                                                      
      uintptr_t nonpointer        : 1; // 标记是否是pointer isa                                       
      uintptr_t has_assoc         : 1; // 标记是否有关联对象                                       
      uintptr_t has_cxx_dtor      : 1; // 标记是否有c++析构函数                                      
      uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ // 标记对象的指针的值
      uintptr_t magic             : 6; // 标记对象是否已经完成了初始化，在 arm64 中 0x16 是调试器判断当前对象是真的对象还是没有初始化的空间(在 x86_64 中该值为 0x3b)                                      
      uintptr_t weakly_referenced : 1; // 标记是否有弱引用                                      
      uintptr_t deallocating      : 1; // 标记对象是否正在被释放                                      
      uintptr_t has_sidetable_rc  : 1; // 标记对象是否有引用计数存储在sidetable                                      
      uintptr_t extra_rc          : 19 // 存储对象的引用计数
// x86_64
#   define ISA_BITFIELD                                                        
      uintptr_t nonpointer        : 1;                                         
      uintptr_t has_assoc         : 1;                                         
      uintptr_t has_cxx_dtor      : 1;                                         
      uintptr_t shiftcls          : 44; /*MACH_VM_MAX_ADDRESS 0x7fffffe00000*/ 
      uintptr_t magic             : 6;                                         
      uintptr_t weakly_referenced : 1;                                         
      uintptr_t deallocating      : 1;                                         
      uintptr_t has_sidetable_rc  : 1;                                         
      uintptr_t extra_rc          : 8

当SUPPORT_PACKED_ISA为1的时候就会定义ISA_BITFIELD;可以看到64位是支持nonpointer isa的32位就不支持了

// Define SUPPORT_PACKED_ISA=1 on platforms that store the class in the isa 
// field as a maskable pointer with other data around it.
#if (!__LP64__  ||  TARGET_OS_WIN32  ||  \
     (TARGET_OS_SIMULATOR && !TARGET_OS_IOSMAC))
#   define SUPPORT_PACKED_ISA 0
#else
#   define SUPPORT_PACKED_ISA 1
#endif
2. release内部实现
- (oneway void)release {
    _objc_rootRelease(self);
}

NEVER_INLINE void
_objc_rootRelease(id obj)
{
    ASSERT(obj);

    obj->rootRelease();
}

ALWAYS_INLINE bool 
objc_object::rootRelease()
{
    return rootRelease(true, false);
}

跳来跳去最后执行到bool objc_object::rootRelease(bool performDealloc, bool handleUnderflow)函数
performDealloc标记当引用计数-1之后<=0的时候执行dealloc
handleUnderflow表示需要去sidetable中去借引用计数

2.1 TaggedPointer对象

if (isTaggedPointer()) return false;

tagged pointer没有引用计数这一说，所以它的release、dealloc是直接返回，内存管理由系统来处理

2.2 Pointer isa对象释放
pointer isa的对象(包含不支持nonpointer isa的架构以及支持但是isa没有存储额外信息的场景)，引用计数是存储在sidetable中的，release的时候也是直接从sidetable中取引用计数然后-1

对于不支持nonpointer isa的情况，rootRelease的实现

inline bool 
objc_object::rootRelease()
{
    if (isTaggedPointer()) return false;
    return sidetable_release(true);
}

对于支持nonpointer isa的，但是isa中没存储额外的信息，isa的nonpointer为
截取rootRelease中的处理逻辑如下：

if (slowpath(!newisa.nonpointer)) { // nonpointer的isa，但是isa中也没有存储额外信息的情况，引用计数存储在sidetable，直接调用sidetable_release(true)
     ClearExclusive(&isa.bits);
     if (rawISA()->isMetaClass()) return false;
         if (sideTableLocked) sidetable_unlock();
            return sidetable_release(performDealloc);
}

sidetable_release实现如下：

uintptr_t
objc_object::sidetable_release(bool performDealloc)
{
#if SUPPORT_NONPOINTER_ISA
    ASSERT(!isa.nonpointer);
#endif
    SideTable& table = SideTables()[this];

    bool do_dealloc = false;

    table.lock();
    //try_emplace:https://en.cppreference.com/w/cpp/container/map/try_emplace
    auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING); // try_emplace的作用是key对应的记录存在则啥都不做，不存在的话则将value存储到对应的key
    auto &refcnt = it.first->second;
    if (it.second) { // there was no entry 没有记录，那么就直接dealloc
        do_dealloc = true;
    } else if (refcnt < SIDE_TABLE_DEALLOCATING) { // 0b10
        // SIDE_TABLE_WEAKLY_REFERENCED may be set. Don't change it.
        do_dealloc = true;
        refcnt |= SIDE_TABLE_DEALLOCATING;
    } else if (! (refcnt & SIDE_TABLE_RC_PINNED)) { // #define SIDE_TABLE_RC_PINNED         (1UL<<(WORD_BITS-1))
        /*
         举个例子使用WORD_BITS=8位来演算,假设sidetable存储的是0b100 == 4
         SIDE_TABLE_RC_PINNED = 0b10000000
         refcnt = 0b00010000
         1. refcnt & SIDE_TABLE_RC_PINNED ==> 0b00010000 & 0b10000000 = 0b00000000
         2. 只有当引用计数器的高位也为1的时候，才为真；此时溢出了，直接返回了false
        */
        refcnt -= SIDE_TABLE_RC_ONE; // 1UL<<2
        // 假设sidetable存储的是0b100 == 4
        // 0b00010000 - 0b100 = 0b00001100 ==> rc = 0b11 = 3
        // 0b00001100 - 0b100 = 0b00001000 ==> rc = 0b10 = 2
    }
    table.unlock();
    if (do_dealloc  &&  performDealloc) {
        ((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(dealloc));
    }
    return do_dealloc;
}

2.2.1 引用计数器也有一些标记位

  • SIDE_TABLE_DEALLOCATING (1UL<<1) 标记对象是否正在被释放
  • SIDE_TABLE_WEAKLY_REFERENCED (1UL<<0) 标记对象是否有弱引用
  • SIDE_TABLE_RC_PINNED (1UL<<(WORD_BITS-1)) // WORD_BITS 64bit是64 32bit是32，标记对象的引用计数是否已经到顶了
  • SIDE_TABLE_RC_ONE (1UL<<2) 由于后两位是标记位，所以引用计数器-1就是每次减去这个定义的值
假设sidetable存储的是0b100 == 4
0b00010000 - 0b100 = 0b00001100 ==> rc = 0b11 = 3
0b00001100 - 0b100 = 0b00001000 ==> rc = 0b10 = 2

2.2.2 整体的逻辑

  • if (it.second)分支 当sidetable中查没有记录的时候走dealloc流程，此时标记计数器的标记为SIDE_TABLE_DEALLOCATING；

这个分支要结合auto it = table.refcnts.try_emplace(this, SIDE_TABLE_DEALLOCATING)一起看，try_emplace的作用是：key对应的记录存在则啥都不做，不存在的话则将value存储到对应的key，当没有记录的时候会走这个分支，此时try_emplace将SIDE_TABLE_DEALLOCATING存储进去

  • if (refcnt < SIDE_TABLE_DEALLOCATING)分支 当引用计数器的值小于SIDE_TABLE_DEALLOCATING，表示只有weak引用标记，此时将计数器标记为SIDE_TABLE_DEALLOCATING
  • if (refcnt < SIDE_TABLE_DEALLOCATING)分支 当引用计数器计数大于0的时候就执行-1操作

具体的细节可以看上面贴的代码，有注释

2.3 Nonpointer对象释放
2.3.1 nonpointer isa的isa中存储有引用计数的信息，内部实现大概流程是

  1. 先从isa中的extra_rc去减1，当-1之后大于0，则直接返回了
  2. 当-1之后不大于0的时候，就去判断是否有has_sidetable_rc，如果有就从sidetable中存储的引用计数借RC_HALF的计数，并将借来的计数-1存储到isa的extra_rc中，这其中涉及到一系列的容错和尝试的逻辑，目的就是为了将修改后的isa的bits信息成功存储到isa的bits中，如果失败了就再加回到sidetable中存储的引用计数器中去，然后再重试走借的这一套流程
  3. 如果has_sidetable_rc为false，此时就没法借了，就走后面的dealloc流程了

2.3.2 源代码

bool 
objc_object::rootRelease(bool performDealloc, bool handleUnderflow) // true,false
{
    if (isTaggedPointer()) return false;

    bool sideTableLocked = false;

    isa_t oldisa;
    isa_t newisa;

 retry:
    do {
        oldisa = LoadExclusive(&isa.bits);
        newisa = oldisa;
        if (slowpath(!newisa.nonpointer)) { // 支持nonpointer isa，但是isa没存储额外信息，引用计数存储在sidetable，直接调用sidetable_release(true)
            ClearExclusive(&isa.bits);
            if (rawISA()->isMetaClass()) return false;
            if (sideTableLocked) sidetable_unlock();
            return sidetable_release(performDealloc);
        }
        // don't check newisa.fast_rr; we already called any RR overrides
        // nonpointer isa的处理流程
        uintptr_t carry;
        newisa.bits = subc(newisa.bits, RC_ONE, 0, &carry);  // extra_rc--
        if (slowpath(carry)) { // 不够减了
            // don't ClearExclusive()
            goto underflow; // 对于nonpointer isa去sidetable_rc中去借
        }
    } while (slowpath(!StoreReleaseExclusive(&isa.bits, 
                                             oldisa.bits, newisa.bits)));

    if (slowpath(sideTableLocked)) sidetable_unlock();
    return false;

 underflow:
    // newisa.extra_rc-- underflowed: borrow from side table or deallocate
    // 如果extra_rc--小于等于0的时候则去sidetable_rc去每次借1<<7位的数据
    // abandon newisa to undo the decrement
    newisa = oldisa;

    if (slowpath(newisa.has_sidetable_rc)) { // 有引用计数存储在sidetable
        if (!handleUnderflow) {
            ClearExclusive(&isa.bits);
            return rootRelease_underflow(performDealloc); // rootRelease(performDealloc, true);这里也就是会执行到下面的流程handleUnderflow=true，从sidetable借引用计数[sidetable_subExtraRC_nolock(RC_HALF)]存储到extra_rc中去[StoreReleaseExclusive]
        }

        // Transfer retain count from side table to inline storage.

        if (!sideTableLocked) {
            ClearExclusive(&isa.bits);
            sidetable_lock();
            sideTableLocked = true;
            // Need to start over to avoid a race against 
            // the nonpointer -> raw pointer transition.
            goto retry;
        }

        // Try to remove some retain counts from the side table.        
        size_t borrowed = sidetable_subExtraRC_nolock(RC_HALF);

        // To avoid races, has_sidetable_rc must remain set 
        // even if the side table count is now zero.

        if (borrowed > 0) {
            // Side table retain count decreased.
            // Try to add them to the inline count.
            newisa.extra_rc = borrowed - 1;  // redo the original decrement too
            bool stored = StoreReleaseExclusive(&isa.bits, 
                                                oldisa.bits, newisa.bits);
            if (!stored) {
                // 存储失败了，则尝试在存储一次
                // Inline update failed. 
                // Try it again right now. This prevents livelock on LL/SC 
                // architectures where the side table access itself may have 
                // dropped the reservation.
                isa_t oldisa2 = LoadExclusive(&isa.bits);
                isa_t newisa2 = oldisa2;
                if (newisa2.nonpointer) {
                    uintptr_t overflow;
                    newisa2.bits = 
                        addc(newisa2.bits, RC_ONE * (borrowed-1), 0, &overflow); // 当超过bits所能表示的范围的时候 overflow就返回1，否则为0
                    if (!overflow) {
                        stored = StoreReleaseExclusive(&isa.bits, oldisa2.bits, 
                                                       newisa2.bits); // 将isa.bits由oldisa2.bits交换为newisa2.bits
                    }
                }
            }
            // 还是失败了则放回到sidetable_rc中去，重新走这个流程
            if (!stored) {
                // Inline update failed.
                // Put the retains back in the side table.
                sidetable_addExtraRC_nolock(borrowed);
                goto retry;
            }

            // Decrement successful after borrowing from side table.
            // This decrement cannot be the deallocating decrement - the side 
            // table lock and has_sidetable_rc bit ensure that if everyone 
            // else tried to -release while we worked, the last one would block.
            sidetable_unlock();
            return false;
        }
        else {
            // 没有sidetable存储引用计数，表示对象没有人持有了，此时就走后面的释放流程了
            // Side table is empty after all. Fall-through to the dealloc path.
        }
    }

    // Really deallocate.

    if (slowpath(newisa.deallocating)) { // 如果正在释放的对象，调用了release则抛出异常
        ClearExclusive(&isa.bits);
        if (sideTableLocked) sidetable_unlock();
        return overrelease_error();
        // does not actually return
    }
    newisa.deallocating = true;
    if (!StoreExclusive(&isa.bits, oldisa.bits, newisa.bits)) goto retry;

    if (slowpath(sideTableLocked)) sidetable_unlock();

    __c11_atomic_thread_fence(__ATOMIC_ACQUIRE);

    if (performDealloc) { // 当引用计数--之后<=0的时候就走dealloc
        ((void(*)(objc_object *, SEL))objc_msgSend)(this, @selector(dealloc));
    }
    return true;
}

代码中写了注释，可以了解个大概的流程；其中有2个函数查了资料没查到具体的作用，就写了点例子来测试它的功能

subc-- 作用就是相减，当不够减的时候carry是1，当够减的时候carry为0
subc内部实现：调用__builtin_subcl，写了下面测试用例

 void subcTestCase(void) {
    uintptr_t carryout;
    {
        uintptr_t left = 1;
        uintptr_t result = __builtin_subcl(left, 1, 0, &carryout);
        NSLog(@"case0: result = %lu carryout = %lu", result, carryout); // case0: result = 0 carryout = 0
    }
    {
        uintptr_t left = 2;
        uintptr_t result = __builtin_subcl(left, 1, 0, &carryout);
        NSLog(@"case1: result = %lu carryout = %lu", result, carryout); // case1: result = 1 carryout = 0
    }
    {
        uintptr_t left = 0;
        uintptr_t result = __builtin_subcl(left, 1, 0, &carryout);
        NSLog(@"case2: result = %lu carryout = %lu", result, carryout); // case2: result = 18446744073709551615 carryout = 1
    }
    {
        uintptr_t left = 0;
        uintptr_t result = __builtin_subcl(left, 5, 0, &carryout);
        NSLog(@"case3: result = %lu carryout = %lu", result, carryout); // case3: result = 18446744073709551611 carryout = 1
    }
}

addc-- 作用就是相加，当相加之后的值超过了第一个参数类型所能表示的范围就会溢出overflow为1否则为0
写了一下测试用例

void addcTestCase(void) {
    // unsigned long uintptr_t
    uintptr_t borrowed = (1ULL<<7);
    uintptr_t right = (1ULL<<56) * (borrowed - 1);
    uintptr_t overflow;
    {
        uintptr_t left = 1ULL<<63;
        uintptr_t result = __builtin_addcl(left, right, 0, &overflow);
        NSLog(@"case0: result = %lu overflow = %lu", result, overflow); // case0: result = 18374686479671623680 overflow = 0
    }
    {
        uintptr_t left = NSUIntegerMax - 1;
        uintptr_t result = __builtin_addcl(left, right, 0, &overflow);
        NSLog(@"case1: result = %lu overflow = %lu", result, overflow); // case1: result = 9151314442816847870 overflow = 1
    }
}
3. dealloc内部实现

上面也说到release内部如果计数--之后为0了就内部会走到dealloc的流程；dealloc的内部实现对TaggedPointer、Nonpointer isa Pointer isa会怎么处理了

dealloc内部调用_objc_rootDealloc(id obj) ，其内部调用了obj->rootDealloc();

我们直接看rootDealloc的实现

对于不支持nonpointer isa的架构，直接object_dispose

inline void
objc_object::rootDealloc()
{
    if (isTaggedPointer()) return;
    object_dispose((id)this);
}

对于支持nonpointer isa的架构

inline void
objc_object::rootDealloc()
{
    if (isTaggedPointer()) return;  // fixme necessary?

    if (fastpath(isa.nonpointer  &&  
                 !isa.weakly_referenced  &&  
                 !isa.has_assoc  &&  
                 !isa.has_cxx_dtor  &&  
                 !isa.has_sidetable_rc))
    {
        // 对象的isa中没有需要额外处理的释放相关的，直接释放
        assert(!sidetable_present());
        free(this);
    } 
    else {
        object_dispose((id)this);
    }
}

3.1 整体逻辑

对于不支持nonpointer isa的架构

  • 直接object_dispose

对于支持nonpointer isa的架构

  • TaggedPointer直接返回
  • nonpointer isa对象的isa中没有存储需要额外处理的标记则直接free
  • 否则调用object_dispose去处理释放逻辑

3.2 object_dispose

id 
object_dispose(id obj)
{
    if (!obj) return nil;

    objc_destructInstance(obj);    
    free(obj);

    return nil;
}

可以看到当isa中有特殊的标记的时候，dealloc的时候需要做一些额外的逻辑，然后再free;

3.2.1 额外的析构逻辑objc_destructInstance

  • 调用c++析构函数，如果有的话
  • 调用移除关联对象，如果有的话
  • 清除掉对象的弱引用表记录以及sidetable中的计数记录，如果有的话
void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor(); // 是否有c++析构方法
        bool assoc = obj->hasAssociatedObjects(); // 是否有关联对象

        // This order is important.
        if (cxx) object_cxxDestruct(obj); // 调用c++析构函数
        if (assoc) _object_remove_assocations(obj); // 移除关联对象
        obj->clearDeallocating(); // 清除弱引用以及sidetable中的记录
    }

    return obj;
}

3.2.2 clearDeallocating

inline void 
objc_object::clearDeallocating()
{
    if (slowpath(!isa.nonpointer)) {
        // Slow path for raw pointer isa.
        sidetable_clearDeallocating(); // ponter isa则从sidetable中取引用计数器做处理
    }
    else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
        // Slow path for non-pointer isa with weak refs and/or side table data.
        clearDeallocating_slow(); // nonpointer isa如果有弱引用或者引用计数存储在sidetable则做对应的清除处理
    }

    assert(!sidetable_present());
}

这里都是对有弱引用或者sidetable存储的引用计数信息的情况进行处理；区别就是nonpointer isa本身存储了这些标记信息，则可以根据标记信息去做对应的清除逻辑；而历看是否有对应的引用计数器信息，再根据pointer isa则需要去sidetable里面去遍历计数器的标记位去做对应的清除逻辑

pointer isa的处理

void 
objc_object::sidetable_clearDeallocating()
{
    SideTable& table = SideTables()[this];

    // clear any weak table items
    // clear extra retain count and deallocating bit
    // (fixme warn or abort if extra retain count == 0 ?)
    table.lock();
    RefcountMap::iterator it = table.refcnts.find(this); // 从sidetable找该对象的记录
    if (it != table.refcnts.end()) { // 找到了
        if (it->second & SIDE_TABLE_WEAKLY_REFERENCED) { // 弱引用的标记位来判断是否有弱引用记录
            weak_clear_no_lock(&table.weak_table, (id)this); // 清除弱引用表中的记录
        }
        table.refcnts.erase(it); // 将计数器从sidetable移除
    }
    table.unlock();
}

Nonpointer isa的处理

NEVER_INLINE void
objc_object::clearDeallocating_slow()
{
    ASSERT(isa.nonpointer  &&  (isa.weakly_referenced || isa.has_sidetable_rc));

    SideTable& table = SideTables()[this];
    table.lock();
    if (isa.weakly_referenced) { // 有弱引用记录
        weak_clear_no_lock(&table.weak_table, (id)this);
    }
    if (isa.has_sidetable_rc) { // 有计数信息存储在sidetable
        table.refcnts.erase(this);
    }
    table.unlock();
}
}
4. 总结
  • 苹果为了提高效率以及节约空间，引入了TaggedPointer，同时64位下也采用了Pointer isa合理的利用了64位的空间，isa不仅仅是个指针，还包含了各种标记位，同时也用了几位来存储引用计数，结合sidetable来一起存储引用计数
  • 直接操作isa的效率显然比去sidetable中去读取计数然后修改的效率要高的多，所以苹果有个小的设计--当isa中的extra_rc不足的时候，去sidetable借，然后存储到extra_rc中，这样提高了效率，值得学习和借鉴
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,607评论 5赞 476
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,047评论 2赞 379
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,496评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,405评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,400评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,479评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,883评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,535评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,743评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,544评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,612评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,309评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,881评论 3赞 306
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,891评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,136评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,783评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,316评论 2赞 342