#多线程

你理解的多线程？
多线程方案

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

pthread 􏼑􏴓􏴔
跨平台 、使用难度大，手动管理线程的声明周期
NSThread
基于pthread封装、更加面向对象，简单易用，可直接操作线程对象，手动管理线程的生命周期
GCD
可以设置队列优先级，执行速度比NSOperationQueue快
NSOperation
NSOperationQueue每个任务都可以重新设置优先级，设置依赖关系，最大并发数，暂停取消任务
你在项目中用过 GCD 吗？

GCD 的队列类型

说一下 OperationQueue 和 GCD 的区别，以及各自的优势

多线程优缺点
优点：
程序响应速度更快，界面进行其他操作同时保持活动状态，优化任务执行，提高资源利用率
缺点：
线程占内存空间，管理线程需要额外CPU开销，线程多，降低程序性能，增加程序复杂度

OC你了解的锁有哪些？在你回答基础上进行二次提问；
追问一：自旋和互斥对比？
追问二：使用以上锁需要注意哪些？
追问三：用C/OC/C++，任选其一，实现自旋或互斥？口述即可！

队列的执行效果
产生死锁 :使用sync函数 往 当前 串行 队列添加任务

队列执行效果

打印结果

- (void)test
{
    NSLog(@"2");
}
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        NSLog(@"1");
        // 这句代码的本质是往Runloop中添加定时器
        [self performSelector:@selector(test) withObject:nil afterDelay:.0];
        NSLog(@"3");
        
        //        [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    })

打印结果：1 3
原因：performSelector:withObject:afterDelay:的本质是往Runloop中添加定时器
子线程默认没有启动Runloop

 NSThread *thread = [[NSThread alloc] initWithBlock:^{
        NSLog(@"1");
        
   //     [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
    //   [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    }];
    [thread start];
    
    [self performSelector:@selector(test) onThread:thread withObject:nil waitUntilDone:YES];

打印结果 : 1   线程挂了，开启runloop可以打印结果
多线程安全隐患

资源共享
1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

经典案列 : 卖票、取钱

问题.png

解决方案
使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）
常见的线程同步技术是：加锁

加锁

线程同步方案
  • OSSpinLock(ios10已过期)
    OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源
    目前已经不再安全，可能会出现优先级反转问题
    如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁
    需要导入头文件#import <libkern/OSAtomic.h>
注意点:一定要是同一把锁,不然锁不会生效
 //初始化
    OSSpinLock lock = OS_SPINLOCK_INIT;
    //尝试加锁(如果需要等待就不加锁返回false,不需要等待加锁,返回去true)
    BOOL restult =OSSpinLockTry(&lock);
    //加锁
    OSSpinLockLock(&lock);
    /*需要执行的代码*/
    //解锁
    OSSpinLockUnlock(&lock);
  • os_unfair_lock
    os_unfair_lock用于取代不安全的OSSpinLock ，从iOS10开始才支持
    从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等
    需要导入头文件#import <os/lock.h> 
    //初始化
   os_unfair_lock ticketLock = OS_UNFAIR_LOCK_INIT;
  //尝试加锁(如果需要等待就不加锁返回false,不需要等待加锁,返回去true)
   BOOL result = os_unfair_lock_trylock(&_ticketLock);
    //加锁
   os_unfair_lock_lock(&_ticketLock);
   /*需要执行代码*/
    //解锁
    os_unfair_lock_unlock(&_ticketLock);
  • pthread_mutex
    mutex叫做”互斥锁”，等待锁的线程会处于休眠状态
    需要导入头文件#import <pthread.h> 
  // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
    // 初始化锁
    pthread_mutex_t mutex;
    pthread_mutex_init(mutex, &attr);
    //尝试加锁
    pthread_mutex_trylock(&mutex);
    //加锁
     pthread_mutex_lock(&mutex);
    //解锁
    pthread_mutex_unlock(&mutex);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
     // 销毁锁
    pthread_mutex_destroy(&mutex);
Mutex类型

**pthread_mutex – 递归锁 **

 // 递归锁：允许同一个线程对一把锁进行重复加锁
    
    // 初始化属性
    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_mutex – 条件 **


条件
@interface MutexDemo3()
@property (assign, nonatomic) pthread_mutex_t mutex;
@property (assign, nonatomic) pthread_cond_t cond;
@property (strong, nonatomic) NSMutableArray *data;
@end

@implementation MutexDemo3

- (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);
}
  • dispatch_semaphore
    semaphore叫做”信号量”
    信号量的初始值，可以用来控制线程并发访问的最大数量
    信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步
#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)test
{
    SemaphoreBegin;
    /*执行代码*/
    SemaphoreEnd;
}
  • dispatch_queue(DISPATCH_QUEUE_SERIAL)
    直接使用GCD的串行队列，也是可以实现线程同步的
@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
  • NSLock
    NSLock是对mutex普通锁的封装
    NSLock
@interface NSLockDemo()
@property (strong, nonatomic) NSLock *ticketLock;
@property (strong, nonatomic) NSLock *moneyLock;
@end

@implementation NSLockDemo


- (instancetype)init
{
    if (self = [super init]) {
        self.ticketLock = [[NSLock alloc] init];
        self.moneyLock = [[NSLock alloc] init];
    }
    return self;
}

// 死锁：永远拿不到锁
- (void)__saleTicket
{
    [self.ticketLock lock];
    
    [super __saleTicket];
    
    [self.ticketLock unlock];
}

- (void)__saveMoney
{
    [self.moneyLock lock];
    
    [super __saveMoney];
    
    [self.moneyLock unlock];
}

- (void)__drawMoney
{
    [self.moneyLock lock];
    
    [super __drawMoney];
    
    [self.moneyLock unlock];
}

@end
  • NSRecursiveLock
    NSRecursiveLock也是对mutex递归锁的封装，API跟NSLock基本一致
  • NSCondition
    NSCondition是对mutex和cond的封装
    NSCondition
@interface NSConditionDemo()
@property (strong, nonatomic) NSCondition *condition;
@property (strong, nonatomic) NSMutableArray *data;
@end

@implementation NSConditionDemo

- (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];
    
    sleep(2);
    
    [self.condition unlock];
}
  • NSConditionLock
    NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值
    NSConditionLock
@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];
}
  • @synchronized
    @synchronized是对mutex递归锁的封装
    源码查看：objc4中的objc-sync.mm文件
    @synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作
- (void)otherTest
{
    @synchronized([self class]) {
        NSLog(@"123");
        [self otherTest];
    }
}
iOS线程同步方案性能比较

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

自旋锁、互斥锁比较

自旋锁 忙等，互斥锁会休眠
什么情况使用自旋锁比较划算

  • 预计线程等待锁的时间很短
  • 加锁的代码（临界区）经常被调用，但竞争情况很少发生
  • CPU资源不紧张
  • 多核处理器

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

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

atom：原子，不可再分割的单位
atomic：原子性(执行过程不能被打断 ，加锁)
atomic用于保证属性setter、getter的原子性操作，相当于在getter和setter内部加了线程同步的锁
可以参考源码objc4的objc-accessors.mm
它并不能保证使用属性的过程是线程安全的

iOS中的读写安全方案

思考如何实现以下场景(多读单写)？
同一时间，只能有1个线程进行写的操作
同一时间，允许有多个线程进行读的操作
同一时间，不允许既有写的操作，又有读的操作

- (void)setName:(NSString *)name
{
    // 加锁
    _name = name;
    // 解锁
}

解决方案

  • pthread_rwlock：读写锁
#import <pthread.h>

@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);
}
  • dispatch_barrier_async：异步栅栏调用
@interface ViewController ()
@property (strong, nonatomic) dispatch_queue_t queue;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
    
    for (int i = 0; i < 10; i++) {
        dispatch_async(self.queue, ^{
            [self read];
        });
        
        dispatch_async(self.queue, ^{
            [self read];
        });
        
        dispatch_async(self.queue, ^{
            [self read];
        });
        
        dispatch_barrier_async(self.queue, ^{
            [self write];
        });
    }
}


- (void)read {
    sleep(1);
    NSLog(@"read");
}

- (void)write
{
    sleep(1);
    NSLog(@"write");
}

@end

GNUstep
GNUstep是GNU计划的项目之一，它将Cocoa的OC库重新开源实现了一遍
源码地址：http://www.gnustep.org/resources/downloads.php
虽然GNUstep不是苹果官方源码，但还是具有一定的参考价值

一、线程之间的通讯

1、
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 下载图片
        UIImage *image = nil;
        dispatch_async(dispatch_get_main_queue(), ^{
             回到主线程
        });

2、  [self performSelector:@selector(settingImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES modes:nil];

[self performSelectorOnMainThread:@selector(settingImage:) withObject:image waitUntilDone:YES];

3、NSMarchPort

二、多线程安全的解决方法
1、只在主线程刷新访问UI
2、如果要防止线程资源抢夺，得用synchronized进行枷锁保护
3、如果异步线程要保证线程安全问题，尽量使用GCD(有些函数默认是线程安全的)

三、GCD内部实现
GCD内部实现.png

四、NSOperationQueue 与GCD的区别

进程

进程是指在系统中正在运行的一个应用程序
每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内

线程

1、进程不具备执行任务的能力，1个进程要想执行任务，必须得有线程，每1个进程至少要有1条线程，一个进程（程序）的所有任务都在线程中执行
2、线程中任务的执行是串行的，同一时间内，1个线程只能执行1个任务

多线程

1个进程中可以开启多条线程，多条线程可以并行（同时）执行不同的任务

多线程的原理

同一时间，CPU只能处理1条线程，只有1条线程在工作（执行）
多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换）
如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象

如果线程非常非常多，会发生什么情况？
CPU会在N多线程之间调度，CPU会累死，消耗大量的CPU资源
每条线程被调度执行的频次会降低（线程的执行效率降低）

多线程的优点

能适当提高程序的执行效率
能适当提高资源利用率（CPU、内存利用率）

多线程的缺点

1、创建线程是有开销的，iOS下主要成本包括：内核数据结构（大约1KB）、栈空间（子线程512KB、主线程1MB，也可以使用-setStackSize:设置，但必须是4K的倍数，而且最小是16K）创建线程大约需要90毫秒的创建时间
2、如果开启大量的线程，会降低程序的性能
3、线程越多，CPU在调度线程上的开销就越大
4、程序设计更加复杂：比如线程之间的通信、多线程的数据共享

主线程

一个iOS程序运行后，默认会开启1条线程，称为“主线程”或“UI线程”

主线程的主要作用
显示\刷新UI界面
处理UI事件

主线程的使用注意
别将比较耗时的操作放到主线程中
耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验

如何获取主线程
如果是主线程, 那么名称叫做main/ number = 1

**注意: **
currentThread代表拿到当前线程, 如果当前执行的方法是被主线程执行的, 那么拿到的就是主线程, 如果不是被主线程执行的, 那么拿到的就不是主线程
::[NSThread currentThread] 获取当前线程
::[NSThread mainThread] 主线程

判断当前方法是否实在主线程中执行的
[NSThread isMainThread] 返回bool值

iOS中多线程的实现方案

image.png

pthread

image.png

NSThread

image.png

没有返回值,没法对线程进行更详细的设置


image.png

线程的状态

1、alloc/init 创建一个线程,那么当前线程的状态就处于新建状态New
2、调用start 就会将创建好的线程放在调度池中，线程能够执行是因为被CPU调度了，只有处于调度池中的线程才会被CPU
3、调度，在调度池中线程处于就绪状态Runnable
cpu调度线程，线程状态就会从就绪状态Runnable 变为运行状态Running
4、CPU调度其他线程 当前线程状态就会从运行状态Running 变为就绪状态Runnable
5、当线程sleep或者被锁住了,线程就会从运行状态Running _ 变为阻塞Block状态_ ,线程就会从 调度池里移除
6、当前sleep时间到了,线程就会被重新添加到调度池中,状态就会从阻塞Block状态 变为 就绪状态Runnable
7、当线程任务执行完或者线程被强制关闭，线程就会处于死亡Dead状态

image.png

互斥锁
开发中如果需要加锁, 一般都使用self


image.png

原子和非原子属性
OC在定义属性时有nonatomic和atomic两种选
1、atomic：原子属性，为setter方法加锁（默认就是atomic）
2、非原子属性，不会为setter方法加锁
atomic：线程安全，需要消耗大量的资源
nonatomic：非线程安全，适合内存小的移动设备

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

Synchronized: 互斥锁
Atomic: 自旋锁
互斥锁和自旋锁共同点:
都能够保证同一时刻只能有一个线程操作锁住的代码
互斥锁和自旋锁区别:
互斥锁: 当上一个线程的任务没有执行完毕的时候(被锁住), 那么下一个线程会进入睡眠状态等待任务执行完毕, 当上一个线程的任务执行完毕, 下一个线程会自动唤醒, 然后执行任务
自旋锁:当上一个线程的任务没有执行完毕的时候(被锁住),那么下一个线程会一直等待(不会睡眠),当上一个线程的任务执行完毕,下一个线程会立即执行任务
自旋锁应用场景:
比较适合做一些不耗时的操作

线程间通信
什么叫做线程间通信？
在1个进程中，线程往往不是孤立存在的，多个线程之间需要经常进行通信

线程间通信的体现
1个线程传递数据给另1个线程
在1个线程中执行完特定任务后，转到另1个线程继续执行任务

线程间通信常用方法
::- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;

::- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;

子线程下载图片的demo

image.png

image.png
NSOperation、GCD 区别

NSOperation相比于GCD 可以取消或者暂停任务，可以设置依赖任务，控制最大并发数

NSThread、GCD 区别

NSThread 通过􏲒􏲓@selector 􏵜􏲇􏳮􏲼􏲦􏰀􏰚􏰛􏱛􏰜􏳎􏵣􏵤指定执行的房法，代码分散，如果开线程需要创建多个线程对象，线程直接的并发控制需要我们自己来控制，通过NSCondition实现
GCD通过block指定要执行的代码，代码集中，易于维护和阅读，不要管理线程的生命周期

什么时候使用GCD、什么时候使用NSOperation

GCD的优点是GCD本身非常简单、易用，节省代码量
NSOperation是对线程的高度抽象，使用它项目结构更好，子类化NSOperation设计思路，具有面向对象的优点(复用、封装)，接口简单

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

推荐阅读更多精彩内容

  • 多线程
    Object C中创建线程的方法是什么？如果在主线程中执行代码，方法是什么？如果想延时执行代码、方法又是什么？ 1...
    AlanGe阅读 1,708评论 0赞 17
  • 多线程总结
    一.资源抢夺 2> 资源抢夺解决方案 @sychronized{ } dispatch_barrier_async...
    蓝心儿的蓝色之旅阅读 1,359评论 0赞 4
  • iOS多线程之GCD
    多线程 在iOS开发中为提高程序的运行效率会将比较耗时的操作放在子线程中执行，iOS系统进程默认启动一个主线程，用...
    郭豪豪阅读 2,581评论 0赞 4
  • iOS多线程（一）
    首先了解单线程:一、单线程的应用,整个应用中只有一个顺序执行流,当执行流在执行某个耗时的操作,或者不能立即完成的任...
    蓝白自由阅读 564评论 1赞 8
  • 独生小娃娃3
    线直一点，朴；线弯一点，俏。 弧度大一点，瓦！弧度小一点，萌。 浅一丝，太过平滑，深一丝，才够错落。 一支铅笔就可...
    一树花开半树林阅读 386评论 3赞 5