【iOS 底层原理】多线程、线程安全和锁

一、基础概念

有4个术语比较容易混淆:同步、异步、并发、串行

1.进程和线程

进程:进程是计算机中已运行程序的实体,是线程的容器。每个进程之间是相互独立的,每个进程均运行在专用且受保护的内存空间内。 把工厂作为一个系统,进程类似于车间。
线程:线程是操作系统能够进行运算调度的最小单位。一个进程的所有任务都在线程中执行。一个线程中执行的任务是串行的,同一时间内1个线程只能执行一个任务。 把工厂作为一个系统,线程类似于车间里干活的工人。

进程和线程之间关系

  • 线程是CPU调用的最小单位
  • 进程手机CPU分配资源的最小单位
  • 一个进程中至少有一个线程
  • 同一个进程内的线程共享进程的资源

多线程:一个进程可以开启多条线程,每条线程可以同时执行不同的任务,多线程技术可以提高程序的执行效率。同一时间内,CPU只能处理1条线程,只有1条线程在工作,多线程并发执行,其实是CPU快速的在多条线程之间调度,如果CPU调度线程的时间足够快,就造成了多线程并发执行的假象。CPU在多条线程之间调度会消耗大量的CPU资源,同时每条线程被调度的频次会降低,因此我们只开辟3-5条线程。

多线程优缺点

  • 优点:1、能适当提高程序的执行效率;2、能适当提高资源利用率(CPU,内存利用率)
  • 缺点: 1、创建线程的开销,在iOS中,内核数据结构(大约1kb)、栈空间(子线程512kb,主线程1MB)创建线程大约需要90毫秒的创建时间,如果开启大量线程会降低程序性能,线程越多,CPU在调度线程上的开销就越大。

线程的状态

image.png

  1. 创建:实例化对象
  2. 就绪:向线程对象发送start消息,线程对象被加入 “可调度线程池”,等待CPU调度,detach 方法 和 performSelectorInBackground 方法会直接实例化一个线程对象并加入 “可调度线程池”
  3. 运行:CPU 负责调度 “可调度线程池”中线程的执行,线程执行完成之前,状态可能会在 “就绪” 和 “运行” 之间来回切换,此过程CPU控制。
  4. 阻塞:当满足某个预定条件时,可以使用休眠或锁阻塞线程执行,影响的方法有:sleepForTimeInterval, sleepUntilDate, @synchronized(self) 线程锁。线程对象进入阻塞状态后,会被“可调度线程池” 中移除,CPU不再调度。
  5. 死亡:死亡后线程对象的 isFinished 属性为YES;如果发送cancel消息,线程对象的 isCanceled 属性为YES;死亡后 stackSize == 0, 内存空间被释放。

1.同步和异步

同步和异步主要影响:

  • 能不能开启新的线程。
  • 会不会阻塞当前线程。

同步:在当前线程中执行任务,不具备开启新线程的能力
异步:在新的线程中执行任务,具备开启新线程的能力(具备开线程的能力,但不一定会开线程)

2.并发和串行

并发和串行主要影响:任务的执行方式

并发:多个任务并发(同时)执行
串行:一个任务执行完毕后,再执行下一个任务

二、多线程方案

image.png

1. GCD

GCD源码:https://github.com/apple/swift-corelibs-libdispatch

同步/异步

GCD中有2个用来执行任务的函数
用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

队列

GCD的队列可以分为2大类型
并发队列(Concurrent Dispatch Queue)

  • 可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
  • 并发功能只有在异步(dispatch_async)函数下才有效

串行队列(Serial Dispatch Queue)

  • 让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)
各队列的执行效果
image.png
dispatch :派遣/调度
queue:队列
    用来存放任务的先进先出(FIFO)的容器
sync:同步
    只是在当前线程中执行任务,不具备开启新线程的能力
async:异步
    可以在新的线程中执行任务,具备开启新线程的能力
concurrent:并发
    多个任务并发(同时)执行
串行:
    一个任务执行完毕后,再执行下一个任务

任务
 - queue:队列
 - block:任务
// 1.用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

// 2.用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

// 3.GCD中还有个用来执行任务的函数
// 在前面的任务执行结束后它才执行,而且它后面的任务等它执行完成之后才会执行
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

使用 GCD 死锁的情况

使用sync函数当前串行队列中添加任务,会卡住当前的串行队列(产生死锁)

队列组

思考:如何用gcd实现以下功能

  • 异步并发执行任务1、任务2
  • 等任务1、任务2都执行完毕后,再回到主线程执行任务3
image.png
GCD 的其他用法

延时执行

dispatch_after(3.0, dispatch_get_main_queue(), ^{
   /// 延时3秒执行的操作!
});

一次性执行

// 使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 只执行1次的代码(这里面默认是线程安全的)
});

队列组

//创建调度组
dispatch_group_t group = dispatch_group_create();
//将调度组添加到队列,执行 block 任务
dispatch_group_async(group, queue, block);
//当调度组中的所有任务执行结束后,获得通知,统一做后续操作
dispatch_group_notify(group, dispatch_get_main_queue(), block);

GCD定时器

dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,0, 0, DISPATCH_TARGET_QUEUE_DEFAULT);
dispatch_source_set_event_handler(source, ^(){
     NSLog(@"Time flies.");
});
dispatch_time_t start
dispatch_source_set_timer(source, DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC,100ull * NSEC_PER_MSEC);
self.source = source;
dispatch_resume(self.source);

2.NSOperation

3.NSThread

demo

- (void)testNSThread {
    /// 获取当前线程
    NSThread *currentThread = [NSThread currentThread];
    
    /// 创建需要自己启动的线程
    NSThread *creatThread = [[NSThread alloc] initWithTarget:self selector:@selector(runMethod) object:nil];
    [creatThread start];

    /// 创建自动启动的线程
    [NSThread detachNewThreadSelector:@selector(runMethod2) toTarget:self withObject:nil];
}
- (void)runMethod {
    NSLog(@"runMethod ++ %@",[NSThread currentThread]);
}
- (void)runMethod2 {
    NSLog(@"runMethod2 ++ %@",[NSThread currentThread]);
}

相关 API

// 获取当前线程
 + (NSThread *)currentThread;
 // 创建启动线程
 + (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;
 // 判断是否是多线程
 + (BOOL)isMultiThreaded;
 // 线程休眠 NSDate 休眠到什么时候
 + (void)sleepUntilDate:(NSDate *)date;
 // 线程休眠时间
 + (void)sleepForTimeInterval:(NSTimeInterval)ti;
 // 结束/退出当前线程
 + (void)exit;
 // 获取当前线程优先级
 + (double)threadPriority;
 // 设置线程优先级 默认为0.5 取值范围为0.0 - 1.0 
 // 1.0优先级最高
 // 设置优先级
 + (BOOL)setThreadPriority:(double)p;
 // 获取指定线程的优先级
 - (double)threadPriority NS_AVAILABLE(10_6, 4_0);
 - (void)setThreadPriority:(double)p NS_AVAILABLE(10_6, 4_0);
 // 设置线程的名字
 - (void)setName:(NSString *)n NS_AVAILABLE(10_5, 2_0);
 - (NSString *)name NS_AVAILABLE(10_5, 2_0);
 // 判断指定的线程是否是 主线程
 - (BOOL)isMainThread NS_AVAILABLE(10_5, 2_0);
 // 判断当前线程是否是主线程
 + (BOOL)isMainThread NS_AVAILABLE(10_5, 2_0); // reports whether current thread is main
 // 获取主线程
 + (NSThread *)mainThread NS_AVAILABLE(10_5, 2_0);
 - (id)init NS_AVAILABLE(10_5, 2_0);    // designated initializer
 // 创建线程
 - (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument NS_AVAILABLE(10_5, 2_0);
 // 指定线程是否在执行
 - (BOOL)isExecuting NS_AVAILABLE(10_5, 2_0);
 // 线程是否完成
 - (BOOL)isFinished NS_AVAILABLE(10_5, 2_0);
 // 线程是否被取消 (是否给当前线程发过取消信号)
 - (BOOL)isCancelled NS_AVAILABLE(10_5, 2_0);
 // 发送线程取消信号的 最终线程是否结束 由 线程本身决定
 - (void)cancel NS_AVAILABLE(10_5, 2_0);
 // 启动线程
 - (void)start NS_AVAILABLE(10_5, 2_0);
 // 线程主函数  在线程中执行的函数 都要在-main函数中调用,自定义线程中重写-main方法
 - (void)main NS_AVAILABLE(10_5, 2_0);    // thread body metho

线程间通信

//在主线程上执行操作,例如给UIImageVIew设置图片
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait
//在指定线程上执行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thread withObject:(id)arg waitUntilDone:(BOOL)wait

三、线程安全方案(锁)

多线程的安全隐患:一块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源

比如多个线程访问同一个对象、同一个变量、同一个文件

当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题

解决方案:使用线程同步技术(同步,就是协同步调,按预定的先后次序进行)。常见的线程同步技术是:加锁

1.iOS 中的线程同步方案

  • OSSpinLock
  • os_unfair_lock
  • pthread_mutex
  • dispatch_semaphore
  • dispatch_queue(DISPATCH_QUEUE_SERIAL)
  • NSLock
  • NSRecursiveLock
  • NSCondition
  • NSConditionLock
  • @synchronized

2.OSSpinLock

OSSpinLock叫做”自旋锁”,等待锁的线程会处于忙等(busy-wait)状态,一直占用着CPU资源。(目前已经不再安全,可能会出现优先级反转问题)

优先级:优先级低的线程先获取锁,而等待锁的线程优先级较高,它会一直占用着CPU资源,优先级低的线程可能一直无法获得时间片,进而无法释放锁

使用:
需要导入头文件#import <libkern/OSAtomic.h>

image.png

3.os_unfair_lock

os_unfair_lock 用于取代不安全的 OSSpinLock ,从 iOS10 开始才支持

从底层调用看,等待 os_unfair_lock 锁的线程会处于休眠状态,并非忙等

需要导入头文件#import <os/lock.h>

image.png

4.pthread_mutex

mutex叫做”互斥锁”,等待锁的线程会处于休眠状态

需要导入头文件#import <pthread.h>

image.png

pthread_mutex 递归锁实现

image.png

pthread_mutex 条件锁实现

image.png

demo

- (instancetype)init
{
    if (self = [super init]) {
        // 初始化属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        // 初始化锁
        pthread_mutex_init(&_mutex, &attr);
        // 销毁属性
        pthread_mutexattr_destroy(&attr);
        
        // 初始化条件
        pthread_cond_init(&_cond, NULL);
        
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式

// 线程1
// 删除数组中的元素
- (void)__remove
{
    pthread_mutex_lock(&_mutex);
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待
        pthread_cond_wait(&_cond, &_mutex);
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    
    pthread_mutex_unlock(&_mutex);
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    pthread_mutex_lock(&_mutex);
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    
    // 信号
    pthread_cond_signal(&_cond);
    // 广播
//    pthread_cond_broadcast(&_cond);
    
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc
{
    pthread_mutex_destroy(&_mutex);
    pthread_cond_destroy(&_cond);
}

remove 方法先获得锁,这时 count ==0 触发等待(pthread_cond_wait),释放锁,add 方法得以执行,在条件满足时,调用 pthread_cond_signal 唤醒之前 wait 的线程。

pthread_cond_wait 的含义

  1. 当条件 &_cond 不满足时,释放锁;从而其他线程可以获得锁
  2. 当前线程休眠
  3. 当条件 &_cond 满足时,重新获得锁

适用场景:类似生产者-消费者模型

5.dispatch_semaphore

image.png

类似 NSOperationQueue 的 maxConcurrentOperationCount 的功能

demo

@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@property (strong, nonatomic) dispatch_semaphore_t ticketSemaphore;
@property (strong, nonatomic) dispatch_semaphore_t moneySemaphore;
@end

@implementation SemaphoreDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.semaphore = dispatch_semaphore_create(5);
        self.ticketSemaphore = dispatch_semaphore_create(1);
        self.moneySemaphore = dispatch_semaphore_create(1);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __drawMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saveMoney
{
    dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saveMoney];
    
    dispatch_semaphore_signal(self.moneySemaphore);
}

- (void)__saleTicket
{
    dispatch_semaphore_wait(self.ticketSemaphore, DISPATCH_TIME_FOREVER);
    
    [super __saleTicket];
    
    dispatch_semaphore_signal(self.ticketSemaphore);
}

- (void)otherTest
{
    for (int i = 0; i < 20; i++) {
        [[[NSThread alloc] initWithTarget:self selector:@selector(test) object:nil] start];
    }
}

// 线程10、7、6、9、8
- (void)test
{
    // 如果信号量的值 > 0,就让信号量的值减1,然后继续往下执行代码
    // 如果信号量的值 <= 0,就会休眠等待,直到信号量的值变成>0,就让信号量的值减1,然后继续往下执行代码
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    
    sleep(2);
    NSLog(@"test - %@", [NSThread currentThread]);
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphore);
}

@end

6.dispatch_queue(DISPATCH_QUEUE_SERIAL)

image.png

demo

@interface SerialQueueDemo()
@property (strong, nonatomic) dispatch_queue_t ticketQueue;
@property (strong, nonatomic) dispatch_queue_t moneyQueue;
@end

@implementation SerialQueueDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL);
        self.moneyQueue = dispatch_queue_create("moneyQueue", DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

- (void)__drawMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __drawMoney];
    });
}

- (void)__saveMoney
{
    dispatch_sync(self.moneyQueue, ^{
        [super __saveMoney];
    });
}

- (void)__saleTicket
{
    dispatch_sync(self.ticketQueue, ^{
        [super __saleTicket];
    });
}

@end

使用技巧

#define SemaphoreBegin \
static dispatch_semaphore_t semaphore; \
static dispatch_once_t onceToken; \
dispatch_once(&onceToken, ^{ \
    semaphore = dispatch_semaphore_create(1); \
}); \
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

#define SemaphoreEnd \
dispatch_semaphore_signal(semaphore);

- (void)test1
{
    SemaphoreBegin;
    
    // .....
    
    SemaphoreEnd;
}

7.NSLock & NSRecursiveLock

NSLock 是对普通 mutex 锁的封装(互斥锁)


image.png

demo

- (void)testNSLock {
    NSLock *lock = [[NSLock alloc] init];
    [lock lock];
    // 需要锁定的代码
    [lock unlock];
}

8.NSCondition

image.png

demo

- (instancetype)init
{
    if (self = [super init]) {
        self.condition = [[NSCondition alloc] init];
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式

// 线程1
// 删除数组中的元素
- (void)__remove
{
    [self.condition lock];
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待
        [self.condition wait];
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    
    [self.condition unlock];
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    [self.condition lock];
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    // 信号
    [self.condition signal];
    
    // 广播
//    [self.condition broadcast];
    [self.condition unlock];
    
}

9.NSConditionLock

image.png

initWithCondition:(NSInteger)condition

  • 初始化,并且设置条件锁内部存储的条件为 condition
  • 如果直接 alloc init 创建,默认初始条件值为 0

lockWhenCondition:(NSInteger)condition 含义

  • 当条件锁内部存储的条件是 condition 时才可以加锁

unlockWithCondition:(NSInteger)condition

  • 解锁,同时设置内部存储的条件为2

lock

  • 直接加锁,不去关心 condition

demo

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one
{
    [self.conditionLock lock];
    
    NSLog(@"__one");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(1);
    
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    
    NSLog(@"__three");
    
    [self.conditionLock unlock];
}

@end

适用场景:处理多个线程间的依赖问题,实现线程间任务按指定顺序执行。

10.@synchronized

image.png

互斥锁:使用互斥锁,在同一个时间,只允许一条线程执行锁中的代码。因为互斥锁的代价非常昂贵,所以锁定的代码范围应该尽可能小,只要锁住资源读写部分的代码即可。使用互斥锁也会影响并发的目的。

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

11.atomic

image.png

OC在定义属性时有nonatomic和atomic两种选择。 atomic:原子属性,为setter方法加锁(默认就是atomic) nonatomic:非原子属性,不会为setter方法加锁。 atomic加锁原理:

 @property (assign, atomic) int age;
 - (void)setAge:(int)age
 { 
     @synchronized(self) { 
        _age = age;
     }
 }

  • atomic:线程安全,需要消耗大量的资源
  • nonatomic:非线程安全,适合内存小的移动设备

iOS开发的建议:
(1)所有属性都声明为nonatomic
(2)尽量避免多线程抢夺同一块资源
(3)尽量将加锁、资源抢夺的业务逻辑交给服务器端处理,减小移动客户端的压力

多余容器对象(NSMutableArray等)进行 add/remove 操作不是线程安全的。

四、锁的性能比较

image.png

推荐使用 dispatch_semaphore 和 pthread_mutex

五、自旋锁与互斥锁比较

什么情况使用自旋锁比较划算?

  1. 预计线程等待锁的时间很短
  2. 加锁的代码(临界区)经常被调用,但竞争情况很少发生
  3. CPU资源不紧张
  4. 多核处理器

什么情况使用互斥锁比较划算?

  1. 预计线程等待锁的时间较长
  2. 单核处理器
  3. 临界区有IO操作
  4. 临界区代码复杂或者循环量大
  5. 临界区竞争非常激烈

六、读写安全(读写锁)

1.iOS中的读写安全方案

思考如何实现以下场景

  • 同一时间,只能有1个线程进行写的操作
  • 同一时间,允许有多个线程进行读的操作
  • 同一时间,不允许既有写的操作,又有读的操作

上面的场景就是典型的“多读单写”,经常用于文件等数据的读写操作,iOS中的实现方案有

  • pthread_rwlock:读写锁
  • dispatch_barrier_async:异步栅栏调用

2.pthread_rwlock

image.png

demo

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

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    pthread_rwlock_init(&_lock, NULL);
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    for (int i = 0; i < 10; i++) {
        dispatch_async(queue, ^{
            [self read];
        });
        dispatch_async(queue, ^{
            [self write];
        });
    }
}


- (void)read {
    pthread_rwlock_rdlock(&_lock);
    
    sleep(1);
    NSLog(@"%s", __func__);
    
    pthread_rwlock_unlock(&_lock);
}

- (void)write
{
    pthread_rwlock_wrlock(&_lock);
    
    sleep(1);
    NSLog(@"%s", __func__);
    
    pthread_rwlock_unlock(&_lock);
}

- (void)dealloc
{
    pthread_rwlock_destroy(&_lock);
}

@end

3.dispatch_barrier_async

image.png

在 dispatch_barrier_async 执行任务时,绝对不允许有其他任务在执行。

image.png

面试题

1.你理解的多线程?

2.iOS的多线程方案有哪几种?你更倾向于哪一种?

3.你在项目中用过 GCD 吗?

4.GCD 的队列类型

5.说一下 OperationQueue 和 GCD 的区别,以及各自的优势

6.线程安全的处理手段有哪些?

7.OC你了解的锁有哪些?在你回答基础上进行二次提问;

追问一:自旋和互斥对比?
追问二:使用以上锁需要注意哪些?
追问三:用C/OC/C++,任选其一,实现自旋或互斥?口述即可!

8.如下

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

推荐阅读更多精彩内容

  • iOS多线程编程 基本知识 1. 进程(process) 进程是指在系统中正在运行的一个应用程序,就是一段程序的执...
    陵无山阅读 5,996评论 1 14
  • 1.ios高性能编程 (1).内层 最小的内层平均值和峰值(2).耗电量 高效的算法和数据结构(3).初始化时...
    欧辰_OSR阅读 29,293评论 8 265
  • iOS多线程实践中,常用的就是子线程执行耗时操作,然后回到主线程刷新UI。在iOS中每个进程启动后都会建立一个主线...
    jackyshan阅读 1,435评论 2 12
  • 这个群体是越来越大了,身为其中的一员,感慨万千。大部分全职主妇并不甘心就呆在家里,养尊处优。既然身为全职主妇,就得...
    天空天天蓝阅读 600评论 5 3
  • 《我们迎面走来》 我们迎面走来 你的声音在我眼中摇摆 我的目光在你耳边徘徊 清风携着一片云彩 你手捧二生的诺言 我...
    管小妤阅读 192评论 0 4