浅谈Block

Block使用场景，可以在两个界面的传值，也可以对代码封装作为参数的传递等。用过GCD就知道Block的精妙之处。

Block简介

Block是一种比较特殊的数据类型。它可以保存一段代码，在合适的时候取出来调用。

iOS代码块Block

概述

代码块Block是苹果在iOS4开始引入的对C语言的扩展,用来实现匿名函数的特性,Block是一种特殊的数据类型,其可以正常定义变量、作为参数、作为返回值,特殊地,Block还可以保存一段代码,在需要的时候调用,目前Block已经广泛应用于iOS开发中,常用于GCD、动画、排序及各类回调

注: Block的声明与赋值只是保存了一段代码段,必须调用才能执行内部代码

Block变量的声明、赋值与调用

Block变量的声明

Block内访问局部变量

在Block中可以访问局部变量

// 声明局部变量global

int global = 100;

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

// 调用后控制台输出"global = 100"

myBlock();

在声明Block之后、调用Block之前对局部变量进行修改,在调用Block时局部变量值是修改之前的旧值

// 声明局部变量global

int global = 100;

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

global = 101;

// 调用后控制台输出"global = 100"

myBlock();

在Block中不可以直接修改局部变量

// 声明局部变量global

int global = 100;

void(^myBlock)() = ^{

global ++; // 这句报错

NSLog(@"global = %d", global);

};

// 调用后控制台输出"global = 100"

myBlock();

注: 原理解析,通过clang命令将OC转为C++代码来查看一下Block底层实现,clang命令使用方式为终端使用cd定位到main.m文件所在文件夹,然后利用clang -rewrite-objc main.m将OC转为C++,成功后在main.m同目录下会生成一个main.cpp文件

// OC代码如下

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

// 转为C++代码如下

void(*myBlock)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, global));

// 将变量类型精简之后C++代码如下,我们发现Block变量实际上就是一个指向结构体__main_block_impl_0的指针,而结构体的第三个元素是局部变量global的值

void(*myBlock)() = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, global);

// 我们看一下结构体__main_block_impl_0的代码

struct __main_block_impl_0 {

struct __block_impl impl;

struct __main_block_desc_0* Desc;

int global;

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _global, int flags=0) : global(_global) {

impl.isa = &_NSConcreteStackBlock;

impl.Flags = flags;

impl.FuncPtr = fp;

Desc = desc;

}

};

// 在OC中调用Block的方法转为C++代码如下,实际上是指向结构体的指针myBlock访问其FuncPtr元素,在定义Block时为FuncPtr元素传进去的__main_block_func_0方法

((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);

// __main_block_func_0方法代码如下,由此可见NSLog的global正是定义Block时为结构体传进去的局部变量global的值

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

int global = __cself->global; // bound by copy

NSLog((NSString *)&__NSConstantStringImpl__var_folders_6y_vkd9wnv13pz6lc_h8phss0jw0000gn_T_main_d5d9eb_mi_0, global);

}

// 由此可知,在Block定义时便是将局部变量的值传给Block变量所指向的结构体,因此在调用Block之前对局部变量进行修改并不会影响Block内部的值,同时内部的值也是不可修改的

Block内访问__block修饰的局部变量

在局部变量前使用下划线下划线block修饰,在声明Block之后、调用Block之前对局部变量进行修改,在调用Block时局部变量值是修改之后的新值

// 声明局部变量global

__block int global = 100;

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

global = 101;

// 调用后控制台输出"global = 101"

myBlock();

在局部变量前使用下划线下划线block修饰,在Block中可以直接修改局部变量

// 声明局部变量global

__block int global = 100;

void(^myBlock)() = ^{

global ++; // 这句正确

NSLog(@"global = %d", global);

};

// 调用后控制台输出"global = 101"

myBlock();

注: 原理解析,通过clang命令将OC转为C++代码来查看一下Block底层实现

// OC代码如下

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

// 转为C++代码如下

void(*myBlock)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_global_0 *)&global, 570425344));

// 将变量类型精简之后C++代码如下,我们发现Block变量实际上就是一个指向结构体__main_block_impl_0的指针,而结构体的第三个元素是局部变量global的指针

void(*myBlock)() = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &global, 570425344);

// 由此可知,在局部变量前使用__block修饰,在Block定义时便是将局部变量的指针传给Block变量所指向的结构体,因此在调用Block之前对局部变量进行修改会影响Block内部的值,同时内部的值也是可以修改的

Block内访问全局变量

在Block中可以访问全局变量

// 声明全局变量global

int global = 100;

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

// 调用后控制台输出"global = 100"

myBlock();

在声明Block之后、调用Block之前对全局变量进行修改,在调用Block时全局变量值是修改之后的新值

// 声明全局变量global

int global = 100;

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

global = 101;

// 调用后控制台输出"global = 101"

myBlock();

在Block中可以直接修改全局变量

// 声明全局变量global

int global = 100;

void(^myBlock)() = ^{

global ++;

NSLog(@"global = %d", global);

};

// 调用后控制台输出"global = 101"

myBlock();

注: 原理解析,通过clang命令将OC转为C++代码来查看一下Block底层实现

// OC代码如下

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

// 转为C++代码如下

void(*myBlock)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

// 将变量类型精简之后C++代码如下,我们发现Block变量实际上就是一个指向结构体__main_block_impl_0的指针,而结构体中并未保存全局变量global的值或者指针

void(*myBlock)() = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);

// 我们看一下结构体__main_block_impl_0的代码

struct __main_block_impl_0 {

struct __block_impl impl;

struct __main_block_desc_0* Desc;

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {

impl.isa = &_NSConcreteStackBlock;

impl.Flags = flags;

impl.FuncPtr = fp;

Desc = desc;

}

};

// 在OC中调用Block的方法转为C++代码如下,实际上是指向结构体的指针myBlock访问其FuncPtr元素,在定义Block时为FuncPtr元素传进去的__main_block_func_0方法

((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);

// __main_block_func_0方法代码如下,由此可见NSLog的global还是全局变量global的值

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

NSLog((NSString *)&__NSConstantStringImpl__var_folders_6y_vkd9wnv13pz6lc_h8phss0jw0000gn_T_main_f35954_mi_0, global);

}

// 由此可知,全局变量所占用的内存只有一份,供所有函数共同调用,在Block定义时并未将全局变量的值或者指针传给Block变量所指向的结构体,因此在调用Block之前对局部变量进行修改会影响Block内部的值,同时内部的值也是可以修改的

Block内访问静态变量

在Block中可以访问静态变量

// 声明静态变量global

static int global = 100;

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

// 调用后控制台输出"global = 100"

myBlock();

在声明Block之后、调用Block之前对静态变量进行修改,在调用Block时静态变量值是修改之后的新值

// 声明静态变量global

static int global = 100;

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

global = 101;

// 调用后控制台输出"global = 101"

myBlock();

在Block中可以直接修改静态变量

// 声明静态变量global

static int global = 100;

void(^myBlock)() = ^{

global ++;

NSLog(@"global = %d", global);

};

// 调用后控制台输出"global = 101"

myBlock();

注: 原理解析,通过clang命令将OC转为C++代码来查看一下Block底层实现

// OC代码如下

void(^myBlock)() = ^{

NSLog(@"global = %d", global);

};

// 转为C++代码如下

void(*myBlock)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &global));

// 将变量类型精简之后C++代码如下,我们发现Block变量实际上就是一个指向结构体__main_block_impl_0的指针,而结构体的第三个元素是静态变量global的指针

void(*myBlock)() = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, &global);

// 我们看一下结构体__main_block_impl_0的代码

struct __main_block_impl_0 {

struct __block_impl impl;

struct __main_block_desc_0* Desc;

int *global;

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_global, int flags=0) : global(_global) {

impl.isa = &_NSConcreteStackBlock;

impl.Flags = flags;

impl.FuncPtr = fp;

Desc = desc;

}

};

// 在OC中调用Block的方法转为C++代码如下,实际上是指向结构体的指针myBlock访问其FuncPtr元素,在定义Block时为FuncPtr元素传进去的__main_block_func_0方法

((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);

// __main_block_func_0方法代码如下,由此可见NSLog的global正是定义Block时为结构体传进去的静态变量global的指针

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

int *global = __cself->global; // bound by copy

NSLog((NSString *)&__NSConstantStringImpl__var_folders_6y_vkd9wnv13pz6lc_h8phss0jw0000gn_T_main_4d124d_mi_0, (*global));

}

// 由此可知,在Block定义时便是将静态变量的指针传给Block变量所指向的结构体,因此在调用Block之前对静态变量进行修改会影响Block内部的值,同时内部的值也是可以修改的

Block在MRC及ARC下的内存管理

Block在MRC下的内存管理

默认情况下,Block的内存存储在栈中,不需要开发人员对其进行内存管理

// 当Block变量出了作用域,Block的内存会被自动释放

void(^myBlock)() = ^{

NSLog(@"------");

};

myBlock();

在Block的内存存储在栈中时,如果在Block中引用了外面的对象,不会对所引用的对象进行任何操作

Person *p = [[Person alloc] init];

void(^myBlock)() = ^{

NSLog(@"------%@", p);

};

myBlock();

[p release]; // Person对象在这里可以正常被释放

如果对Block进行一次copy操作,那么Block的内存会被移动到堆中,这时需要开发人员对其进行release操作来管理内存

void(^myBlock)() = ^{

NSLog(@"------");

};

myBlock();

Block_copy(myBlock);

// do something ...

Block_release(myBlock);

如果对Block进行一次copy操作,那么Block的内存会被移动到堆中,在Block的内存存储在堆中时,如果在Block中引用了外面的对象,会对所引用的对象进行一次retain操作,即使在Block自身调用了release操作之后,Block也不会对所引用的对象进行一次release操作,这时会造成内存泄漏

Person *p = [[Person alloc] init];

void(^myBlock)() = ^{

NSLog(@"------%@", p);

};

myBlock();

Block_copy(myBlock);

// do something ...

Block_release(myBlock);

[p release]; // Person对象在这里无法正常被释放,因为其在Block中被进行了一次retain操作

如果对Block进行一次copy操作,那么Block的内存会被移动到堆中,在Block的内存存储在堆中时,如果在Block中引用了外面的对象,会对所引用的对象进行一次retain操作,为了不对所引用的对象进行一次retain操作,可以在对象的前面使用下划线下划线block来修饰

__block Person *p = [[Person alloc] init];

void(^myBlock)() = ^{

NSLog(@"------%@", p);

};

myBlock();

Block_copy(myBlock);

// do something ...

Block_release(myBlock);

[p release]; // Person对象在这里可以正常被释放

如果对象内部有一个Block属性,而在Block内部又访问了该对象,那么会造成循环引用

情况一

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

@end

@implementation Person

- (void)dealloc

{

NSLog(@"Person dealloc");

Block_release(_myBlock);

[super dealloc];

}

@end

Person *p = [[Person alloc] init];

p.myBlock = ^{

NSLog(@"------%@", p);

};

p.myBlock();

[p release]; // 因为myBlock作为Person的属性,采用copy修饰符修饰(这样才能保证Block在堆里面,以免Block在栈中被系统释放),所以Block会对Person对象进行一次retain操作,导致循环引用无法释放

情况二

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

- (void)resetBlock;

@end

@implementation Person

- (void)resetBlock

{

self.myBlock = ^{

NSLog(@"------%@", self);

};

}

- (void)dealloc

{

NSLog(@"Person dealloc");

Block_release(_myBlock);

[super dealloc];

}

@end

Person *p = [[Person alloc] init];

[p resetBlock];

[p release]; // Person对象在这里无法正常释放,虽然表面看起来一个alloc对应一个release符合内存管理规则,但是实际在resetBlock方法实现中,Block内部对self进行了一次retain操作,导致循环引用无法释放

如果对象内部有一个Block属性,而在Block内部又访问了该对象,那么会造成循环引用,解决循环引用的办法是在对象的前面使用下划线下划线block来修饰,以避免Block对对象进行retain操作

情况一

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

@end

@implementation Person

- (void)dealloc

{

NSLog(@"Person dealloc");

Block_release(_myBlock);

[super dealloc];

}

@end

__block Person *p = [[Person alloc] init];

p.myBlock = ^{

NSLog(@"------%@", p);

};

p.myBlock();

[p release]; // Person对象在这里可以正常被释放

情况二

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

- (void)resetBlock;

@end

@implementation Person

- (void)resetBlock

{

// 这里为了通用一点,可以使用__block typeof(self) p = self;

__block Person *p = self;

self.myBlock = ^{

NSLog(@"------%@", p);

};

}

- (void)dealloc

{

NSLog(@"Person dealloc");

Block_release(_myBlock);

[super dealloc];

}

@end

Person *p = [[Person alloc] init];

[p resetBlock];

[p release]; // Person对象在这里可以正常被释放

Block在ARC下的内存管理

在ARC默认情况下,Block的内存存储在堆中,ARC会自动进行内存管理,程序员只需要避免循环引用即可

// 当Block变量出了作用域,Block的内存会被自动释放

void(^myBlock)() = ^{

NSLog(@"------");

};

myBlock();

在Block的内存存储在堆中时,如果在Block中引用了外面的对象,会对所引用的对象进行强引用,但是在Block被释放时会自动去掉对该对象的强引用,所以不会造成内存泄漏

Person *p = [[Person alloc] init];

void(^myBlock)() = ^{

NSLog(@"------%@", p);

};

myBlock();

// Person对象在这里可以正常被释放

如果对象内部有一个Block属性,而在Block内部又访问了该对象,那么会造成循环引用

情况一

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

@end

@implementation Person

- (void)dealloc

{

NSLog(@"Person dealloc");

}

@end

Person *p = [[Person alloc] init];

p.myBlock = ^{

NSLog(@"------%@", p);

};

p.myBlock();

// 因为myBlock作为Person的属性,采用copy修饰符修饰(这样才能保证Block在堆里面,以免Block在栈中被系统释放),所以Block会对Person对象进行一次强引用,导致循环引用无法释放

情况二

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

- (void)resetBlock;

@end

@implementation Person

- (void)resetBlock

{

self.myBlock = ^{

NSLog(@"------%@", self);

};

}

- (void)dealloc

{

NSLog(@"Person dealloc");

}

@end

Person *p = [[Person alloc] init];

[p resetBlock];

// Person对象在这里无法正常释放,在resetBlock方法实现中,Block内部对self进行了一次强引用,导致循环引用无法释放

如果对象内部有一个Block属性,而在Block内部又访问了该对象,那么会造成循环引用,解决循环引用的办法是使用一个弱引用的指针指向该对象,然后在Block内部使用该弱引用指针来进行操作,这样避免了Block对对象进行强引用

情况一

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

@end

@implementation Person

- (void)dealloc

{

NSLog(@"Person dealloc");

}

@end

Person *p = [[Person alloc] init];

__weak typeof(p) weakP = p;

p.myBlock = ^{

NSLog(@"------%@", weakP);

};

p.myBlock();

// Person对象在这里可以正常被释放

情况二

@interface Person : NSObject

@property (nonatomic, copy) void(^myBlock)();

- (void)resetBlock;

@end

@implementation Person

- (void)resetBlock

{

// 这里为了通用一点,可以使用__weak typeof(self) weakP = self;

__weak Person *weakP = self;

self.myBlock = ^{

NSLog(@"------%@", weakP);

};

}

- (void)dealloc

{

NSLog(@"Person dealloc");

}

@end

Person *p = [[Person alloc] init];

[p resetBlock];

// Person对象在这里可以正常被释放

Block在ARC下的内存管理的官方案例

在MRC中,我们从当前控制器采用模态视图方式present进入MyViewController控制器,在Block中会对myViewController进行一次retain操作,造成循环引用

MyViewController *myController = [[MyViewController alloc] init];

// ...

myController.completionHandler = ^(NSInteger result) {

[myController dismissViewControllerAnimated:YES completion:nil];

};

[self presentViewController:myController animated:YES completion:^{

[myController release];

}];

在MRC中解决循环引用的办法即在变量前使用下划线下划线block修饰,禁止Block对所引用的对象进行retain操作

__block MyViewController *myController = [[MyViewController alloc] init];

// ...

myController.completionHandler = ^(NSInteger result) {

[myController dismissViewControllerAnimated:YES completion:nil];

};

[self presentViewController:myController animated:YES completion:^{

[myController release];

}];

但是上述方法在ARC下行不通,因为下划线下划线block在ARC中并不能禁止Block对所引用的对象进行强引用,解决办法可以是在Block中将myController置空(为了可以修改myController,还是需要使用下划线下划线block对变量进行修饰)

__block MyViewController *myController = [[MyViewController alloc] init];

// ...

myController.completionHandler = ^(NSInteger result) {

[myController dismissViewControllerAnimated:YES completion:nil];

myController = nil;

};

[self presentViewController:myController animated:YES completion:^{}];

上述方法确实可以解决循环引用,但是在ARC中还有更优雅的解决办法,新创建一个弱指针来指向该对象,并将该弱指针放在Block中使用,这样Block便不会造成循环引用

MyViewController *myController = [[MyViewController alloc] init];

// ...

__weak MyViewController *weakMyController = myController;

myController.completionHandler = ^(NSInteger result) {

[weakMyController dismissViewControllerAnimated:YES completion:nil];

};

[self presentViewController:myController animated:YES completion:^{}];

虽然解决了循环引用,但是也容易涉及到另一个问题,因为Block是通过弱引用指向了myController对象,那么有可能在调用Block之前myController对象便已经被释放了,所以我们需要在Block内部再定义一个强指针来指向myController对象

MyViewController *myController = [[MyViewController alloc] init];

// ...

__weak MyViewController *weakMyController = myController;

myController.completionHandler = ^(NSInteger result) {

MyViewController *strongMyController = weakMyController;

if (strongMyController)

{

[strongMyController dismissViewControllerAnimated:YES completion:nil];

}

else

{

// Probably nothing...

}

};

[self presentViewController:myController animated:YES completion:^{}];

这里需要补充一下,在Block内部定义的变量,会在作用域结束时自动释放,Block对其并没有强引用关系,且在ARC中只需要避免循环引用即可,如果只是Block单方面地对外部变量进行强引用,并不会造成内存泄漏

注: 关于下划线下划线block关键字在MRC和ARC下的不同

__block在MRC下有两个作用

1. 允许在Block中访问和修改局部变量

2. 禁止Block对所引用的对象进行隐式retain操作

__block在ARC下只有一个作用

1. 允许在Block中访问和修改局部变量

使用Block进行排序

在开发中,我们一般使用数组的如下两个方法来进行排序

不可变数组的方法: - (NSArray *)sortedArrayUsingComparator:(NSComparator)cmptr

可变数组的方法 : - (void)sortUsingComparator:(NSComparator)cmptr

其中,NSComparator是利用typedef定义的Block类型

typedef NSComparisonResult (^NSComparator)(id obj1, id obj2);

其中,这个返回值为NSComparisonResult枚举,这个返回值用来决定Block的两个参数顺序,我们只需在Block中指明不同条件下Block的两个参数的顺序即可,方法内部会将数组中的元素分别利用Block来进行比较并排序

typedef NS_ENUM(NSInteger, NSComparisonResult)

{

NSOrderedAscending = -1L, // 升序,表示左侧的字符在右侧的字符前边

NSOrderedSame, // 相等

NSOrderedDescending // 降序,表示左侧的字符在右侧的字符后边

};

我们以Person类为例,对Person对象以年龄升序进行排序,具体方法如下

@interface Student : NSObject

@property (nonatomic, assign) int age;

@end

@implementation Student

@end

Student *stu1 = [[Student alloc] init];

stu1.age = 18;

Student *stu2 = [[Student alloc] init];

stu2.age = 28;

Student *stu3 = [[Student alloc] init];

stu3.age = 11;

NSArray *array = @[stu1,stu2,stu3];

array = [array sortedArrayUsingComparator:^NSComparisonResult(id obj1, id obj2) {

Student *stu1 = obj1;

Student *stu2 = obj2;

if (stu1.age > stu2.age)

{

return NSOrderedDescending; // 在这里返回降序,说明在该种条件下,obj1排在obj2的后边

}

else if (stu1.age < stu2.age)

{

return NSOrderedAscending;

}

else

{

return NSOrderedSame;

}

}];

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

浅谈Block

推荐阅读更多精彩内容