多线程【转】

文章目录

GCD简介

任务和队列

GCD的使用步骤

队列的创建方法

任务的创建方法

GCD的基本使用

并行队列 + 同步执行

并行队列 + 异步执行

串行队列 + 同步执行

串行队列 + 异步执行

主队列 + 同步执行

主队列 + 异步执行

GCD线程之间的通讯

GCD的其他方法

GCD的栅栏方法dispatch_barrier_async

GCD的延时执行方法dispatch_after

GCD的一次性代码(只执行一次)dispatch_once

GCD的快速迭代方法dispatch_apply

GCD的队列组dispatch_group

1. GCD简介

什么是GCD呢？我们先来看看百度百科的解释简单了解下概念

引自百度百科

Grand Central Dispatch(GCD) 是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务。在Mac OS X 10.6雪豹中首次推出，也可在IOS 4及以上版本使用。

为什么要用GCD呢？

因为GCD有很多好处啊，具体如下：

GCD可用于多核的并行运算

GCD会自动利用更多的CPU内核（比如双核、四核）

GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）

程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

既然GCD有这么多的好处，那么下面我们就来系统的学习一下GCD的使用方法。

2. 任务和队列

学习GCD之前，先来了解GCD中两个核心概念：任务和队列。

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行和异步执行。两者的主要区别是：是否具备开启新线程的能力。

同步执行（sync）：只能在当前线程中执行任务，不具备开启新线程的能力

异步执行（async）：可以在新的线程中执行任务，具备开启新线程的能力

队列：这里的队列指任务队列，即用来存放任务的队列。队列是一种特殊的线性表，采用FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。在GCD中有两种队列：串行队列和并行队列。

并行队列（Concurrent Dispatch Queue）：可以让多个任务并行（同时）执行（自动开启多个线程同时执行任务）

并行功能只有在异步（dispatch_async）函数下才有效

串行队列（Serial Dispatch Queue）：让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

3. GCD的使用步骤

GCD的使用步骤其实很简单，只有两步。

创建一个队列（串行队列或并行队列）

将任务添加到队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）

下边来看看队列的创建方法和任务的创建方法。

1. 队列的创建方法

可以使用dispatch_queue_create来创建对象，需要传入两个参数，第一个参数表示队列的唯一标识符，用于DEBUG，可为空；第二个参数用来识别是串行队列还是并行队列。DISPATCH_QUEUE_SERIAL表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并行队列。

// 串行队列的创建方法

dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);

// 并行队列的创建方法

dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);

对于并行队列，还可以使用dispatch_get_global_queue来创建全局并行队列。GCD默认提供了全局的并行队列，需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。

2. 任务的创建方法

// 同步执行任务创建方法

dispatch_sync(queue, ^{

NSLog(@"%@",[NSThread currentThread]);    // 这里放任务代码

});

// 异步执行任务创建方法

dispatch_async(queue, ^{

NSLog(@"%@",[NSThread currentThread]);    // 这里放任务代码

});

虽然使用GCD只需两步，但是既然我们有两种队列，两种任务执行方式，那么我们就有了四种不同的组合方式。这四种不同的组合方式是

并行队列 + 同步执行

并行队列 + 异步执行

串行队列 + 同步执行

串行队列 + 异步执行

实际上，我们还有一种特殊队列是主队列，那样就有六种不同的组合方式了。

主队列 + 同步执行

主队列 + 异步执行

那么这几种不同组合方式各有什么区别呢，这里为了方便，先上结果，再来讲解。为图省事，直接查看表格结果，然后可以跳过** 4. GCD的基本使用** 了。

并行队列串行队列主队列

同步(sync)没有开启新线程，串行执行任务没有开启新线程，串行执行任务没有开启新线程，串行执行任务

异步(async)有开启新线程，并行执行任务有开启新线程(1条)，串行执行任务没有开启新线程，串行执行任务

下边我们来分别讲讲这几种不同的组合方式的使用方法。

4. GCD的基本使用

先来讲讲并行队列的两种使用方法。

1. 并行队列 + 同步执行

不会开启新线程，执行完一个任务，再执行下一个任务

- (void) syncConcurrent

{

NSLog(@"syncConcurrent---begin");

dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

NSLog(@"syncConcurrent---end");

}

输出结果：

2016-09-03 19:22:27.577 GCD[11557:1897538] syncConcurrent---begin

2016-09-03 19:22:27.578 GCD[11557:1897538] 1------{number = 1, name = main}

2016-09-03 19:22:27.578 GCD[11557:1897538] 1------{number = 1, name = main}

2016-09-03 19:22:27.578 GCD[11557:1897538] 2------{number = 1, name = main}

2016-09-03 19:22:27.579 GCD[11557:1897538] 2------{number = 1, name = main}

2016-09-03 19:22:27.579 GCD[11557:1897538] 3------{number = 1, name = main}

2016-09-03 19:22:27.579 GCD[11557:1897538] 3------{number = 1, name = main}

2016-09-03 19:22:27.579 GCD[11557:1897538] syncConcurrent---end

从并行队列 + 同步执行中可以看到，所有任务都是在主线程中执行的。由于只有一个线程，所以任务只能一个一个执行。

同时我们还可以看到，所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间，这说明任务是添加到队列中马上执行的。

2. 并行队列 + 异步执行

可同时开启多线程，任务交替执行

- (void) asyncConcurrent

{

NSLog(@"asyncConcurrent---begin");

dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

NSLog(@"asyncConcurrent---end");

}

输出结果：

2016-09-03 19:27:31.503 GCD[11595:1901548] asyncConcurrent---begin

2016-09-03 19:27:31.504 GCD[11595:1901548] asyncConcurrent---end

2016-09-03 19:27:31.504 GCD[11595:1901626] 1------{number = 2, name = (null)}

2016-09-03 19:27:31.504 GCD[11595:1901625] 2------{number = 4, name = (null)}

2016-09-03 19:27:31.504 GCD[11595:1901855] 3------{number = 3, name = (null)}

2016-09-03 19:27:31.504 GCD[11595:1901626] 1------{number = 2, name = (null)}

2016-09-03 19:27:31.504 GCD[11595:1901625] 2------{number = 4, name = (null)}

2016-09-03 19:27:31.505 GCD[11595:1901855] 3------{number = 3, name = (null)}

在并行队列 + 异步执行中可以看出，除了主线程，又开启了3个线程，并且任务是交替着同时执行的。

另一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始异步执行。

接下来再来讲讲串行队列的执行方法。

3. 串行队列 + 同步执行

不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务

- (void) syncSerial

{

NSLog(@"syncSerial---begin");

dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

NSLog(@"syncSerial---end");

}

输出结果为：

2016-09-03 19:29:00.066 GCD[11622:1903904] syncSerial---begin

2016-09-03 19:29:00.067 GCD[11622:1903904] 1------{number = 1, name = main}

2016-09-03 19:29:00.067 GCD[11622:1903904] 1------{number = 1, name = main}

2016-09-03 19:29:00.067 GCD[11622:1903904] 2------{number = 1, name = main}

2016-09-03 19:29:00.067 GCD[11622:1903904] 2------{number = 1, name = main}

2016-09-03 19:29:00.067 GCD[11622:1903904] 3------{number = 1, name = main}

2016-09-03 19:29:00.068 GCD[11622:1903904] 3------{number = 1, name = main}

2016-09-03 19:29:00.068 GCD[11622:1903904] syncSerial---end

在串行队列 + 同步执行可以看到，所有任务都是在主线程中执行的，并没有开启新的线程。而且由于串行队列，所以按顺序一个一个执行。

同时我们还可以看到，所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间，这说明任务是添加到队列中马上执行的。

4. 串行队列 + 异步执行

会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务

- (void) asyncSerial

{

NSLog(@"asyncSerial---begin");

dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

NSLog(@"asyncSerial---end");

}

输出结果为：

2016-09-03 19:30:08.363 GCD[11648:1905817] asyncSerial---begin

2016-09-03 19:30:08.364 GCD[11648:1905817] asyncSerial---end

2016-09-03 19:30:08.364 GCD[11648:1905895] 1------{number = 2, name = (null)}

2016-09-03 19:30:08.364 GCD[11648:1905895] 1------{number = 2, name = (null)}

2016-09-03 19:30:08.364 GCD[11648:1905895] 2------{number = 2, name = (null)}

2016-09-03 19:30:08.364 GCD[11648:1905895] 2------{number = 2, name = (null)}

2016-09-03 19:30:08.365 GCD[11648:1905895] 3------{number = 2, name = (null)}

2016-09-03 19:30:08.365 GCD[11648:1905895] 3------{number = 2, name = (null)}

在串行队列 + 异步执行可以看到，开启了一条新线程，但是任务还是串行，所以任务是一个一个执行。

另一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。

下边讲讲刚才我们提到过的特殊队列——主队列。

主队列：GCD自带的一种特殊的串行队列

所有放在主队列中的任务，都会放到主线程中执行

可使用dispatch_get_main_queue()获得主队列

我们再来看看主队列的两种组合方式。

5. 主队列 + 同步执行

互等卡住不可行(在主线程中调用)

- (void)syncMain

{

NSLog(@"syncMain---begin");

dispatch_queue_t queue = dispatch_get_main_queue();

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_sync(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

NSLog(@"syncMain---end");

}

输出结果

2016-09-03 19:32:15.356 GCD[11670:1908306] syncMain---begin

这时候，我们惊奇的发现，在主线程中使用主队列 + 同步执行，任务不再执行了，而且syncMain---end也没有打印。这是为什么呢？

这是因为我们在主线程中执行这段代码。我们把任务放到了主队列中，也就是放到了主线程的队列中。而同步执行有个特点，就是对于任务是立马执行的。那么当我们把第一个任务放进主队列中，它就会立马执行。但是主线程现在正在处理syncMain方法，所以任务需要等syncMain执行完才能执行。而syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务。

那么，现在的情况就是syncMain方法和第一个任务都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain---end也没有打印。

要是如果不再主线程中调用，而在其他线程中调用会如何呢？

不会开启新线程，执行完一个任务，再执行下一个任务（在其他线程中调用）

dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{

[self syncMain];

});

输出结果：

2016-09-03 19:32:45.496 GCD[11686:1909617] syncMain---begin

2016-09-03 19:32:45.497 GCD[11686:1909374] 1------{number = 1, name = main}

2016-09-03 19:32:45.498 GCD[11686:1909374] 1------{number = 1, name = main}

2016-09-03 19:32:45.498 GCD[11686:1909374] 2------{number = 1, name = main}

2016-09-03 19:32:45.498 GCD[11686:1909374] 2------{number = 1, name = main}

2016-09-03 19:32:45.499 GCD[11686:1909374] 3------{number = 1, name = main}

2016-09-03 19:32:45.499 GCD[11686:1909374] 3------{number = 1, name = main}

2016-09-03 19:32:45.499 GCD[11686:1909617] syncMain---end

在其他线程中使用主队列 + 同步执行可看到：所有任务都是在主线程中执行的，并没有开启新的线程。而且由于主队列是串行队列，所以按顺序一个一个执行。

同时我们还可以看到，所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间，这说明任务是添加到队列中马上执行的。

6. 主队列 + 异步执行

只在主线程中执行任务，执行完一个任务，再执行下一个任务

- (void)asyncMain

{

NSLog(@"asyncMain---begin");

dispatch_queue_t queue = dispatch_get_main_queue();

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

dispatch_async(queue, ^{

for (int i = 0; i < 2; ++i) {

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

}

});

NSLog(@"asyncMain---end");

}

输出结果：

2016-09-03 19:33:54.995 GCD[11706:1911313] asyncMain---begin

2016-09-03 19:33:54.996 GCD[11706:1911313] asyncMain---end

2016-09-03 19:33:54.996 GCD[11706:1911313] 1------{number = 1, name = main}

2016-09-03 19:33:54.997 GCD[11706:1911313] 1------{number = 1, name = main}

2016-09-03 19:33:54.997 GCD[11706:1911313] 2------{number = 1, name = main}

2016-09-03 19:33:54.997 GCD[11706:1911313] 2------{number = 1, name = main}

2016-09-03 19:33:54.997 GCD[11706:1911313] 3------{number = 1, name = main}

2016-09-03 19:33:54.997 GCD[11706:1911313] 3------{number = 1, name = main}

我们发现所有任务都在主线程中，虽然是异步执行，具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中，并且一个接一个执行。

另一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。

弄懂了难理解、绕来绕去的队列+任务之后，我们来学习一个简单的东西——GCD线程之间的通讯。

5. GCD线程之间的通讯

在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

for (int i = 0; i < 2; ++i) {

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

}

// 回到主线程

dispatch_async(dispatch_get_main_queue(), ^{

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

});

});

输出结果：

2016-09-03 19:34:59.165 GCD[11728:1913039] 1------{number = 2, name = (null)}

2016-09-03 19:34:59.166 GCD[11728:1913039] 1------{number = 2, name = (null)}

2016-09-03 19:34:59.166 GCD[11728:1912961] 2-------{number = 1, name = main}

可以看到在其他线程中先执行操作，执行完了之后回到主线程执行主线程的相应操作。

6. GCD的其他方法

1. GCD的栅栏方法dispatch_barrier_async

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。

- (void)barrier

{

dispatch_queue_t queue = dispatch_queue_create("12312312", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{

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

});

dispatch_async(queue, ^{

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

});

dispatch_barrier_async(queue, ^{

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

});

dispatch_async(queue, ^{

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

});

dispatch_async(queue, ^{

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

});

}

输出结果：

2016-09-03 19:35:51.271 GCD[11750:1914724] ----1-----{number = 2, name = (null)}

2016-09-03 19:35:51.272 GCD[11750:1914722] ----2-----{number = 3, name = (null)}

2016-09-03 19:35:51.272 GCD[11750:1914722] ----barrier-----{number = 3, name = (null)}

2016-09-03 19:35:51.273 GCD[11750:1914722] ----3-----{number = 3, name = (null)}

2016-09-03 19:35:51.273 GCD[11750:1914724] ----4-----{number = 2, name = (null)}

可以看出在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。

2. GCD的延时执行方法dispatch_after

当我们需要延迟执行一段代码时，就需要用到GCD的dispatch_after方法。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

// 2秒后异步执行这里的代码...

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

});

3. GCD的一次性代码(只执行一次)dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

// 只执行1次的代码(这里面默认是线程安全的)

});

4. GCD的快速迭代方法dispatch_apply

通常我们会用for循环遍历，但是GCD给我们提供了快速迭代的方法dispatch_apply，使我们可以同时遍历。比如说遍历0~5这6个数字，for循环的做法是每次取出一个元素，逐个遍历。dispatch_apply可以同时遍历多个数字。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_apply(6, queue, ^(size_t index) {

NSLog(@"%zd------%@",index, [NSThread currentThread]);

});

输出结果：

2016-09-03 19:37:02.250 GCD[11764:1915764] 1------{number = 1, name = main}

2016-09-03 19:37:02.250 GCD[11764:1915885] 0------{number = 2, name = (null)}

2016-09-03 19:37:02.250 GCD[11764:1915886] 2------{number = 3, name = (null)}

2016-09-03 19:37:02.251 GCD[11764:1915764] 4------{number = 1, name = main}

2016-09-03 19:37:02.250 GCD[11764:1915884] 3------{number = 4, name = (null)}

2016-09-03 19:37:02.251 GCD[11764:1915885] 5------{number = 2, name = (null)}

从输出结果中前边的时间中可以看出，几乎是同时遍历的。

5. GCD的队列组dispatch_group

有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。

我们可以先把任务放到队列中，然后将队列放入队列组中。

调用队列组的dispatch_group_notify回到主线程执行操作。

dispatch_group_t group =  dispatch_group_create();

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

// 执行1个耗时的异步操作

});

dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

// 执行1个耗时的异步操作

});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{

// 等前面的异步操作都执行完毕后，回到主线程...

});

彻底学会多线程系列其他文章：

iOS多线程--彻底学会多线程之『pthread、NSThread』

iOS多线程--彻底学会多线程之『NSOperation』

iOS多线程--彻底学会多线程之『RunLoop』

作者：行走的少年郎

链接：http://www.jianshu.com/p/2d57c72016c6

來源：简书

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

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

推荐阅读更多精彩内容

  • iOS 多线程之GCD
    1. GCD简介 什么是GCD呢？我们先来看看百度百科的解释简单了解下概念 引自百度百科：Grand Centra...
    千寻_544f阅读 359评论 0赞 0
  • iOS 多线程：「GCD」详尽总结
    本文首发于我的个人博客：「程序员充电站」[https://itcharge.cn]文章链接：「传送门」[https...
    ITCharge阅读 347,141评论 308赞 1,924
  • 笔耕不辍之孤独是一个人的狂欢
    孤独是一个人的狂欢，狂欢是一个人的寂寞。此话听来很有意味深长的感觉，只有当夜深人静时，给孩子讲完故事哄睡着后，才是...
    理疗瑜伽邵阅读 203评论 1赞 0
  • 小乖成长记（3）
    写在前面的话 从一个朋友那知道简书的，下载软件发现确实不错，于是就注册了号。 今天是第一次发文章，想想就以wuli...
    小乖的爸爸阅读 514评论 0赞 2