iOS多线程：十种线程锁

目录
一，安全隐患
二，OSSpinLock
三，os_unfair_lock
四，pthread_mutex
五，NSLock
六，NSRecursiveLock
七，NSCondition
八，NSConditionLock
九，@synchronized
十，总结
十一，pthread_rwlock

一，安全隐患

1，实例

@interface ViewController ()
@property (nonatomic, assign) int money;
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self saveAndDrawMoney];
}
- (void)saveAndDrawMoney {
    self.money = 100;
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saveMoney];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self drawMoney];
        }
    });
}

- (void)saveMoney {
    [self _saveMoney];
}
- (void)_saveMoney {
    int oldMoney = self.money;
    sleep(0.3);
    oldMoney += 40;
    self.money = oldMoney;
    NSLog(@"存40元，余额%d元---%@", self.money, [NSThread currentThread]);
}

- (void)drawMoney {
    [self _drawMoney];
}
- (void)_drawMoney {
    int oldMoney = self.money;
    sleep(0.3);
    oldMoney -= 20;
    self.money = oldMoney;
    NSLog(@"取20元，余额%d元---%@", self.money, [NSThread currentThread]);
}
@end

// 打印（最后余额应该是200的）
取20元，余额80元---<NSThread: 0x6000030ad1c0>{number = 7, name = (null)}
存40元，余额140元---<NSThread: 0x6000030a0340>{number = 6, name = (null)}
取20元，余额60元---<NSThread: 0x6000030ad1c0>{number = 7, name = (null)}
存40元，余额100元---<NSThread: 0x6000030a0340>{number = 6, name = (null)}
取20元，余额80元---<NSThread: 0x6000030ad1c0>{number = 7, name = (null)}
存40元，余额120元---<NSThread: 0x6000030a0340>{number = 6, name = (null)}
取20元，余额100元---<NSThread: 0x6000030ad1c0>{number = 7, name = (null)}
存40元，余额140元---<NSThread: 0x6000030a0340>{number = 6, name = (null)}
取20元，余额120元---<NSThread: 0x6000030ad1c0>{number = 7, name = (null)}
存40元，余额160元---<NSThread: 0x6000030a0340>{number = 6, name = (null)}

2，图解

安全隐患

3，解决方案

  • 使用线程同步技术让线程按顺序对同一资源进行访问

  • 最常用的线程同步技术是对资源进行加锁

加锁
二，OSSpinLock

1，使用

#import <libkern/OSAtomic.h>

@interface ViewController ()
@property (nonatomic, assign) OSSpinLock lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = OS_SPINLOCK_INIT;
    [self saveAndDrawMoney];
}

- (void)saveMoney {
    // 将_lock锁上
    OSSpinLockLock(&_lock);
    [self _saveMoney];
    // 将_lock打开
    OSSpinLockUnlock(&_lock);
}

- (void)drawMoney {
    // 将_lock锁上
    OSSpinLockLock(&_lock);
    [self _drawMoney];
    // 将_lock打开
    OSSpinLockUnlock(&_lock);
}

// 打印
存40元，余额140元---<NSThread: 0x6000033cfac0>{number = 5, name = (null)}
存40元，余额180元---<NSThread: 0x6000033cfac0>{number = 5, name = (null)}
存40元，余额220元---<NSThread: 0x6000033cfac0>{number = 5, name = (null)}
存40元，余额260元---<NSThread: 0x6000033cfac0>{number = 5, name = (null)}
存40元，余额300元---<NSThread: 0x6000033cfac0>{number = 5, name = (null)}
取20元，余额280元---<NSThread: 0x6000033c7900>{number = 4, name = (null)}
取20元，余额260元---<NSThread: 0x6000033c7900>{number = 4, name = (null)}
取20元，余额240元---<NSThread: 0x6000033c7900>{number = 4, name = (null)}
取20元，余额220元---<NSThread: 0x6000033c7900>{number = 4, name = (null)}
取20元，余额200元---<NSThread: 0x6000033c7900>{number = 4, name = (null)}

2，说明

  • 当线程执行到OSSpinLockLock函数时，会判断_lock是否已锁上，如果否就将它锁上并继续往下执行，如果是就等待它被打开

  • 等待有两种：忙等和休眠，忙等会一直占用着CPU资源，休眠则不会

  • 等待OSSpinLock（自旋锁）的线程会处于忙等状态

3，不推荐使用

  • iOS10开始就被废弃了

  • 不安全，可能会出现优先级反转问题

如果处于忙等状态的线程优先级较高，它会一直占用着CPU资源，优先级较低的线程就无法将锁打开，从而导致死锁

三，os_unfair_lock

1，使用

#import <os/lock.h>

@interface ViewController ()
@property (nonatomic, assign) os_unfair_lock lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = OS_UNFAIR_LOCK_INIT;
    [self saveAndDrawMoney];
}

- (void)saveMoney {
    // 将_lock锁上
    os_unfair_lock_lock(&_lock);
    [self _saveMoney];
    // 将_lock打开
    os_unfair_lock_unlock(&_lock);
}

- (void)drawMoney {
    // 将_lock锁上
    os_unfair_lock_lock(&_lock);
    [self _drawMoney];
    // 将_lock打开
    os_unfair_lock_unlock(&_lock);
}

2，说明

  • 从iOS10开始支持，用于取代不安全的OSSpinLock

  • 等待os_unfair_lock的线程会处于休眠状态

  • 如果忘记将锁打开，其他线程会一直等待，从而导致死锁

四，pthread_mutex
1，normal（互斥锁）
  • 使用
#import <pthread.h>

@interface ViewController ()
@property (nonatomic, assign) pthread_mutex_t mutex;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL); // normal
    // 初始化锁
    pthread_mutex_init(&_mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
    
    [self saveAndDrawMoney];
}

- (void)saveMoney {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    [self _saveMoney];
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}

- (void)drawMoney {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    [self _drawMoney];
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc {
    // 销毁锁
    pthread_mutex_destroy(&_mutex);
}
  • 说明

1>初始化锁时，属性可以传NULL

2>等待pthread_mutex的线程会处于休眠状态

2，recursive（递归锁）
  • 使用
- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); // recursive
    // 初始化锁
    pthread_mutex_init(&_mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self recursive];
    });
}

- (void)recursive {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    
    static int count = 0;
    count++;
    if (count <= 5) {
        NSLog(@"%s---%@", __func__, [NSThread currentThread]);
        // 递归
        [self recursive];
    }
    
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}

// 打印
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
  • 说明

1>如果递归调用的方法里有用到锁，那么就必须用递归锁，否则会出现死锁

2>同一个线程可以对递归锁进行重复上锁

3，pthread_cond（条件锁）
  • 使用
@interface ViewController ()
@property (nonatomic, assign) pthread_cond_t cond;
@property (nonatomic, strong) NSMutableArray *mArray;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    pthread_mutex_init(&_mutex, NULL);
    // 初始化条件
    pthread_cond_init(&_cond, NULL);
    
    [self condition];
}

- (void)condition {
    self.mArray = [NSMutableArray new];
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(queue, ^{
        sleep(1.0);
        [self add];
    });
    
    dispatch_async(queue, ^{
        [self remove];
    });
}

- (void)add {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    
    [self.mArray addObject:@"1"];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    // 发送信号
    pthread_cond_signal(&_cond);
    
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}

- (void)remove {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    
    if (self.mArray.count == 0) {
        // 等待信号
        pthread_cond_wait(&_cond, &_mutex);
    }
    [self.mArray removeLastObject];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc {
    // 销毁锁
    pthread_mutex_destroy(&_mutex);
    // 销毁条件
    pthread_cond_destroy(&_cond);
}

// 打印
-[ViewController add]---<NSThread: 0x6000005e3980>{number = 5, name = (null)}
-[ViewController remove]---<NSThread: 0x6000005944c0>{number = 7, name = (null)}
  • 说明

1>某个线程中的操作在某种情况下需要依赖另外一个线程中的操作，那么就可以用条件来实现

2>pthread_cond_wait函数会让线程进入休眠状态，并且将锁打开

3>当收到信号时，pthread_cond_wait函数会唤醒线程，并且将锁再次锁上

五，NSLock

它是对pthread_mutex（normal）的封装

@interface ViewController ()
@property (nonatomic, strong) NSLock *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = [NSLock new];
    [self saveAndDrawMoney];
}

- (void)saveMoney {
    // 将lock锁上
    [self.lock lock];
    [self _saveMoney];
    // 将lock打开
    [self.lock unlock];
}

- (void)drawMoney {
    // 将lock锁上
    [self.lock lock];
    [self _drawMoney];
    // 将lock打开
    [self.lock unlock];
}
六，NSRecursiveLock

它是对pthread_mutex（recursive）的封装

@interface ViewController ()
@property (nonatomic, strong) NSRecursiveLock *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = [NSRecursiveLock new];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self recursive];
    });
}

- (void)recursive {
    // 将lock锁上
    [self.lock lock];
    
    static int count = 0;
    count++;
    if (count <= 5) {
        NSLog(@"%s---%@", __func__, [NSThread currentThread]);
        // 递归
        [self recursive];
    }
    
    // 将lock打开
    [self.lock unlock];
}
七，NSCondition

它是对pthread_mutex和pthread_cond的封装

@interface ViewController ()
@property (nonatomic, strong) NSCondition *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = [NSCondition new];
    [self condition];
}

- (void)add {
    // 将lock锁上
    [self.lock lock];

    [self.mArray addObject:@"1"];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    // 发送信号
    [self.lock signal];

    // 将lock打开
    [self.lock unlock];
}

- (void)remove {
    // 将lock锁上
    [self.lock lock];

    if (self.mArray.count == 0) {
        // 等待信号
        [self.lock wait];
    }
    [self.mArray removeLastObject];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 将lock打开
    [self.lock unlock];
}
八，NSConditionLock

它是对NSCondition的封装，可以利用条件值来控制线程的执行顺序

@interface ViewController ()
@property (nonatomic, strong) NSConditionLock *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 条件值初始化为1
    self.lock = [[NSConditionLock alloc] initWithCondition:1];
    [self condition];
}

- (void)condition {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(queue, ^{
        [self one];
    });

    dispatch_async(queue, ^{
        [self two];
    });
    
    dispatch_async(queue, ^{
        [self three];
    });
}

- (void)one {
    // 条件值为3往下执行，否则等待
    [self.lock lockWhenCondition:3];

    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 不设置条件值
    [self.lock unlock];
    
    NSLog(@"当前条件值---%zd", self.lock.condition);
}

- (void)two {
    // 条件值为2往下执行，否则等待
    [self.lock lockWhenCondition:2];

    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 条件值设置为3
    [self.lock unlockWithCondition:3];
    
    NSLog(@"当前条件值---%zd", self.lock.condition);
}

- (void)three {
    // 条件值为1往下执行，否则等待
    [self.lock lockWhenCondition:1];

    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 条件值设置为2
    [self.lock unlockWithCondition:2];
    
    NSLog(@"当前条件值---%zd", self.lock.condition);
}

// 打印
-[ViewController three]---<NSThread: 0x600002ae7400>{number = 4, name = (null)}
当前条件值---2
-[ViewController two]---<NSThread: 0x600002ae2680>{number = 6, name = (null)}
当前条件值---3
-[ViewController one]---<NSThread: 0x600002adfa80>{number = 7, name = (null)}
当前条件值---3
九，@synchronized

1，实例代码

- (void)viewDidLoad {
    [super viewDidLoad];
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self recursive];
    });
}

- (void)recursive {
    @synchronized (self) { // 调用objc_sync_enter函数
        static int count = 0;
        count++;
        if (count <= 5) {
            NSLog(@"%s---%@", __func__, [NSThread currentThread]);
            [self recursive];
        } 
    } // 调用objc_sync_exit函数
}

// 打印
-[ViewController recursive]---<NSThread: 0x6000037a5280>{number = 7, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000037a5280>{number = 7, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000037a5280>{number = 7, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000037a5280>{number = 7, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000037a5280>{number = 7, name = (null)}

2，底层代码（源码下载地址）

  • objc_sync_enter
int objc_sync_enter(id obj)
{
    int result = OBJC_SYNC_SUCCESS;
    
    if (obj) {
        // 用obj生成一个锁
        SyncData* data = id2data(obj, ACQUIRE);
        assert(data);
        // 将锁锁上
        data->mutex.lock();
    } else {
        // @synchronized(nil) does nothing
        if (DebugNilSync) {
            _objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");
        }
        objc_sync_nil();
    }
    
    return result;
}

typedef struct alignas(CacheLineSize) SyncData {
    struct SyncData* nextData;
    DisguisedPtr<objc_object> object;
    int32_t threadCount;  // number of THREADS using this block
    // 递归锁
    recursive_mutex_t mutex;
} SyncData;
  • objc_sync_exit
int objc_sync_exit(id obj)
{
    int result = OBJC_SYNC_SUCCESS;
    
    if (obj) {
        // 用obj获取之前生成的锁
        SyncData* data = id2data(obj, RELEASE);
        if (!data) {
            result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
        } else {
            // 将锁打开
            bool okay = data->mutex.tryUnlock();
            if (!okay) {
                result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
            }
        }
    } else {
        // @synchronized(nil) does nothing
    }
    
    return result;
}
十，总结

1，关系图

关系图

2，性能图

性能图

⚠️注意⚠️：因为休眠和唤醒比忙等更加消耗CPU资源，所以互斥锁比自旋锁性能低

十一，pthread_rwlock

1，说明

  • 多读单写

1>同一时间，允许有多个线程进行读的操作

2>同一时间，只能有一个线程进行写的操作

3>同一时间，不允许既有写的操作，又有读的操作

  • pthread_rwlock是读写锁，专用于“多读单写”的场景

  • 等待pthread_rwlock的线程会处于休眠状态

2，使用

@interface ViewController ()
@property (nonatomic, assign) pthread_rwlock_t lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    pthread_rwlock_init(&_lock, NULL);
    [self readAndWrite];
}

- (void)readAndWrite {
    for (int i = 0; i < 5; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [self read];
            [self write];
        });
    }
}

- (void)read {
    // 将_lock锁上（读）
    pthread_rwlock_rdlock(&_lock);
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    sleep(1.0);
    // 将_lock打开
    pthread_rwlock_unlock(&_lock);
}

- (void)write {
    // 将_lock锁上（写）
    pthread_rwlock_wrlock(&_lock);
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    sleep(1.0);
    // 将_lock打开
    pthread_rwlock_unlock(&_lock);
}

- (void)dealloc {
    // 销毁锁
    pthread_rwlock_destroy(&_lock);
}

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

推荐阅读更多精彩内容