Java 線程池 實(shí)現(xiàn)原理與源碼深度解析

正文

史上最清晰的線程池源碼分析

鼎鼎大名的線程池格二。不需要多說!!!!!

這篇博客深入分析 Java 中線程池的實(shí)現(xiàn)纷妆。

總覽

下圖是 java 線程池幾個相關(guān)類的繼承結(jié)構(gòu):

先簡單說說這個繼承結(jié)構(gòu),Executor 位于最頂層愕秫,也是最簡單的,就一個 execute(Runnable runnable) 接口方法定義。

ExecutorService 也是接口吆你,在 Executor 接口的基礎(chǔ)上添加了很多的接口方法,所以一般來說我們會使用這個接口俊犯。

然后再下來一層是 AbstractExecutorService妇多,從名字我們就知道,這是抽象類燕侠,這里實(shí)現(xiàn)了非常有用的一些方法供子類直接使用者祖,之后我們再細(xì)說。

然后才到我們的重點(diǎn)部分 ThreadPoolExecutor 類绢彤,這個類提供了關(guān)于線程池所需的非常豐富的功能七问。

線程池中的 BlockingQueue 也是非常重要的概念,如果線程數(shù)達(dá)到 corePoolSize茫舶,我們的每個任務(wù)會提交到等待隊(duì)列中械巡,等待線程池中的線程來取任務(wù)并執(zhí)行。這里的 BlockingQueue 通常我們使用其實(shí)現(xiàn)類 LinkedBlockingQueue、ArrayBlockingQueue 和 SynchronousQueue坟比,每個實(shí)現(xiàn)類都有不同的特征芦鳍,使用場景之后會慢慢分析。想要詳細(xì)了解各個 BlockingQueue 的讀者葛账,可以參考我的前面的一篇對 BlockingQueue 的各個實(shí)現(xiàn)類進(jìn)行詳細(xì)分析的文章柠衅。

使用示例

1 package main.java.Juc;

2

3 import java.util.concurrent.ExecutorService;

4 import java.util.concurrent.Executors;

5

6 class MyRunnable implements Runnable {

7? ? @Override

8? ? public void run() {

9? ? ? ? for (int x = 0; x < 100; x++) {

10? ? ? ? ? ? System.out.println(Thread.currentThread().getName() + ":" + x);

11? ? ? ? }

12? ? }

13 }

14

15 public class TestThreadPool {

16? ? public static void main(String[] args) {

17? ? ? ? // 創(chuàng)建一個線程池對象,控制要創(chuàng)建幾個線程對象籍琳。

18? ? ? ? ExecutorService pool = Executors.newFixedThreadPool(2);

19

20? ? ? ? // 可以執(zhí)行Runnable對象或者Callable對象代表的線程

21? ? ? ? pool.execute(new MyRunnable());

22? ? ? ? pool.execute(new MyRunnable());

23

24? ? ? ? //結(jié)束線程池

25? ? ? ? pool.shutdown();

26? ? }

27 }

運(yùn)行結(jié)果:

Executor 接口

1 public interface Executor {

2? ? void execute(Runnable command);

3 }

我們可以看到 Executor 接口非常簡單菲宴,就一個void execute(Runnable command)方法,代表提交一個任務(wù)趋急。

當(dāng)然了喝峦,Executor 這個接口只有提交任務(wù)的功能,太簡單了呜达,我們想要更豐富的功能谣蠢,比如我們想知道執(zhí)行結(jié)果、我們想知道當(dāng)前線程池有多少個線程活著查近、已經(jīng)完成了多少任務(wù)等等眉踱,這些都是這個接口的不足的地方。接下來我們要介紹的是繼承自Executor接口的ExecutorService接口霜威,這個接口提供了比較豐富的功能谈喳,也是我們最常使用到的接口。

ExecutorService

那么我們簡單初略地來看一下這個接口中都有哪些方法:

1 public interface ExecutorService extends Executor {

2

3? ? // 關(guān)閉線程池戈泼,已提交的任務(wù)繼續(xù)執(zhí)行婿禽,不接受繼續(xù)提交新任務(wù)

4? ? void shutdown();

5

6? ? // 關(guān)閉線程池,嘗試停止正在執(zhí)行的所有任務(wù)大猛,不接受繼續(xù)提交新任務(wù)

7? ? // 它和前面的方法相比扭倾,加了一個單詞“now”,區(qū)別在于它會去停止當(dāng)前正在進(jìn)行的任務(wù)

8? ? List<Runnable> shutdownNow();

9

10? ? // 線程池是否已關(guān)閉

11? ? boolean isShutdown();

12

13? ? // 如果調(diào)用了 shutdown() 或 shutdownNow() 方法后挽绩,所有任務(wù)結(jié)束了吆录,那么返回true

14? ? // 這個方法必須在調(diào)用shutdown或shutdownNow方法之后調(diào)用才會返回true

15? ? boolean isTerminated();

16

17? ? // 等待所有任務(wù)完成,并設(shè)置超時時間

18? ? // 我們這么理解琼牧,實(shí)際應(yīng)用中是恢筝,先調(diào)用 shutdown 或 shutdownNow,

19? ? // 然后再調(diào)這個方法等待所有的線程真正地完成巨坊,返回值意味著有沒有超時

20? ? boolean awaitTermination(long timeout, TimeUnit unit)

21? ? ? ? ? ? throws InterruptedException;

22

23? ? // 提交一個 Callable 任務(wù)

24? ? <T> Future<T> submit(Callable<T> task);

25

26? ? // 提交一個 Runnable 任務(wù)撬槽,第二個參數(shù)將會放到 Future 中,作為返回值趾撵,

27? ? // 因?yàn)?Runnable 的 run 方法本身并不返回任何東西

28? ? <T> Future<T> submit(Runnable task, T result);

29

30? ? // 提交一個 Runnable 任務(wù)

31? ? Future<?> submit(Runnable task);

32? ?

33? ? ......

34 }

這些方法都很好理解侄柔,一個簡單的線程池主要就是這些功能共啃,能提交任務(wù),能獲取結(jié)果暂题,能關(guān)閉線程池移剪,這也是為什么我們經(jīng)常用這個接口的原因。

AbstractExecutorService


AbstractExecutorService 抽象類派生自 ExecutorService 接口薪者,然后在其基礎(chǔ)上實(shí)現(xiàn)了幾個實(shí)用的方法纵苛,這些方法提供給子類進(jìn)行調(diào)用。

這個抽象類實(shí)現(xiàn)了?ExecutorService 中的?submit 方法言津,newTaskFor 方法用于將任務(wù)包裝成 FutureTask攻人。定義于最上層接口 Executor中的void execute(Runnable command)由于不需要獲取結(jié)果,不會進(jìn)行 FutureTask 的包裝悬槽。

1 public abstract class AbstractExecutorService implements ExecutorService {

2

3? ? // RunnableFuture 是用于獲取執(zhí)行結(jié)果的怀吻,我們常用它的子類 FutureTask

4? ? // 下面兩個 newTaskFor 方法用于將我們的任務(wù)包裝成 FutureTask 提交到線程池中執(zhí)行

5? ? protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {

6? ? ? ? return new FutureTask<T>(runnable, value);

7? ? }

8

9? ? protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {

10? ? ? ? return new FutureTask<T>(callable);

11? ? }

12

13? ? // 提交任務(wù)

14? ? public Future<?> submit(Runnable task) {

15? ? ? ? if (task == null) throw new NullPointerException();

16? ? ? ? // 1. 將任務(wù)包裝成 FutureTask

17? ? ? ? RunnableFuture<Void> ftask = newTaskFor(task, null);

18? ? ? ? // 2. 交給執(zhí)行器執(zhí)行,execute 方法由具體的子類來實(shí)現(xiàn)

19? ? ? ? // 前面也說了初婆,F(xiàn)utureTask 間接實(shí)現(xiàn)了Runnable 接口蓬坡。

20? ? ? ? execute(ftask);

21? ? ? ? return ftask;

22? ? }

23

24? ? public <T> Future<T> submit(Runnable task, T result) {

25? ? ? ? if (task == null) throw new NullPointerException();

26? ? ? ? // 1. 將任務(wù)包裝成 FutureTask

27? ? ? ? RunnableFuture<T> ftask = newTaskFor(task, result);

28? ? ? ? // 2. 交給執(zhí)行器執(zhí)行

29? ? ? ? execute(ftask);

30? ? ? ? return ftask;

31? ? }

32

33? ? public <T> Future<T> submit(Callable<T> task) {

34? ? ? ? if (task == null) throw new NullPointerException();

35? ? ? ? // 1. 將任務(wù)包裝成 FutureTask

36? ? ? ? RunnableFuture<T> ftask = newTaskFor(task);

37? ? ? ? // 2. 交給執(zhí)行器執(zhí)行

38? ? ? ? execute(ftask);

39? ? ? ? return ftask;

40? ? }

41 }

到這里,我們發(fā)現(xiàn)磅叛,這個抽象類包裝了一些基本的方法渣窜,可是 submit等方法,它們都沒有真正開啟線程來執(zhí)行任務(wù)宪躯,它們都只是在方法內(nèi)部調(diào)用了 execute 方法,所以最重要的 execute(Runnable runnable) 方法還沒出現(xiàn)位迂,這里我們要說的就是 ThreadPoolExecutor 類了访雪。

ThreadPoolExecutor

我們經(jīng)常會使用Executors這個工具類來快速構(gòu)造一個線程池,對于初學(xué)者而言掂林,這種工具類是很有用的臣缀,開發(fā)者不需要關(guān)注太多的細(xì)節(jié),只要知道自己需要一個線程池泻帮,僅僅提供必需的參數(shù)就可以了精置,其他參數(shù)都采用作者提供的默認(rèn)值。

1 public static ExecutorService newFixedThreadPool(int nThreads) {

2? ? return new ThreadPoolExecutor(nThreads, nThreads,

3? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 0L, TimeUnit.MILLISECONDS,

4? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new LinkedBlockingQueue<Runnable>());

5 }

6 public static ExecutorService newCachedThreadPool() {

7? ? return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

8? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 60L, TimeUnit.SECONDS,

9? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new SynchronousQueue<Runnable>());

10 }

這里先不說有什么區(qū)別锣杂,它們最終都會導(dǎo)向這個構(gòu)造方法:

1 public ThreadPoolExecutor(int corePoolSize,

2? ? ? ? ? ? ? ? ? ? ? ? ? int maximumPoolSize,

3? ? ? ? ? ? ? ? ? ? ? ? ? long keepAliveTime,

4? ? ? ? ? ? ? ? ? ? ? ? ? TimeUnit unit,

5? ? ? ? ? ? ? ? ? ? ? ? ? BlockingQueue<Runnable> workQueue,

6? ? ? ? ? ? ? ? ? ? ? ? ? ThreadFactory threadFactory,

7? ? ? ? ? ? ? ? ? ? ? ? ? RejectedExecutionHandler handler) {

8? ? if (corePoolSize < 0 ||

9? ? ? ? maximumPoolSize <= 0 ||

10? ? ? ? maximumPoolSize < corePoolSize ||

11? ? ? ? keepAliveTime < 0)

12? ? ? ? throw new IllegalArgumentException();

13? ? // 這幾個參數(shù)都是必須要有的

14? ? if (workQueue == null || threadFactory == null || handler == null)

15? ? ? ? throw new NullPointerException();

16

17? ? this.corePoolSize = corePoolSize;

18? ? this.maximumPoolSize = maximumPoolSize;

19? ? this.workQueue = workQueue;

20? ? this.keepAliveTime = unit.toNanos(keepAliveTime);

21? ? this.threadFactory = threadFactory;

22? ? this.handler = handler;

23 }

上面的構(gòu)造方法中列出了我們最需要關(guān)心的幾個屬性了脂倦,下面逐個介紹下構(gòu)造方法中出現(xiàn)的這幾個屬性:

corePoolSize

    線程池中的核心線程數(shù)。

maximumPoolSize

    最大線程數(shù)元莫,線程池允許創(chuàng)建的最大線程數(shù)赖阻。如果當(dāng)前阻塞隊(duì)列滿了,且繼續(xù)提交任務(wù)踱蠢,則創(chuàng)建新的線程執(zhí)行任務(wù)火欧,前提是當(dāng)前線程數(shù)小于maximumPoolSize;當(dāng)阻塞隊(duì)列是無界隊(duì)列, 則maximumPoolSize則不起作用,?因?yàn)闊o法提交至核心線程池的線程會一直持續(xù)地放入workQueue

workQueue

    用來保存等待被執(zhí)行的任務(wù)的阻塞隊(duì)列. 在JDK中提供了如下阻塞隊(duì)列:

(1) ArrayBlockingQueue:基于數(shù)組結(jié)構(gòu)的有界阻塞隊(duì)列,按FIFO排序任務(wù)苇侵;

(2) LinkedBlockingQuene:基于鏈表結(jié)構(gòu)的阻塞隊(duì)列赶盔,按FIFO排序任務(wù),吞吐量通常要高于ArrayBlockingQuene榆浓;

(3) SynchronousQuene:一個不存儲元素的阻塞隊(duì)列于未,每個插入操作必須等到另一個線程調(diào)用移除操作,否則插入操作一直處于阻塞狀態(tài)哀军,吞吐量通常要高于LinkedBlockingQuene沉眶;

(4) priorityBlockingQuene:具有優(yōu)先級的無界阻塞隊(duì)列;

    有興趣的可以看看我前面關(guān)于BlockingQuene的文章

keepAliveTime

空閑線程的鄙际剩活時間谎倔,如果某線程的空閑時間超過這個值都沒有任務(wù)給它做,那么可以被關(guān)閉了猿推。注意這個值并不會對所有線程起作用片习,如果線程池中的線程數(shù)少于等于核心線程數(shù) corePoolSize,那么這些線程不會因?yàn)榭臻e太長時間而被關(guān)閉蹬叭,當(dāng)然藕咏,也可以通過調(diào)用allowCoreThreadTimeOut(true)使核心線程數(shù)內(nèi)的線程也可以被回收;默認(rèn)情況下秽五,該參數(shù)只在線程數(shù)大于corePoolSize時才有用, 超過這個時間的空閑線程將被終止孽查。

unit

    keepAliveTime的單位

threadFactory

    用于生成線程,一般我們可以用默認(rèn)的就可以了坦喘。通常盲再,我們可以通過它將我們的線程的名字設(shè)置得比較可讀一些,如 Message-Thread-1瓣铣, Message-Thread-2 類似這樣答朋。

handler

    線程池的飽和策略,當(dāng)阻塞隊(duì)列滿了棠笑,且沒有空閑的工作線程梦碗,如果繼續(xù)提交任務(wù),必須采取一種策略處理該任務(wù)蓖救,線程池提供了4種策略:?

AbortPolicy:直接拋出異常洪规,默認(rèn)策略;

CallerRunsPolicy:用調(diào)用者所在的線程來執(zhí)行任務(wù)循捺;

DiscardOldestPolicy:丟棄阻塞隊(duì)列中靠最前的任務(wù)淹冰,并執(zhí)行當(dāng)前任務(wù);

DiscardPolicy:直接丟棄任務(wù)巨柒;

當(dāng)然也可以根據(jù)應(yīng)用場景實(shí)現(xiàn)RejectedExecutionHandler接口樱拴,自定義飽和策略柠衍,如記錄日志或持久化存儲不能處理的任務(wù)。

除了上面幾個屬性外晶乔,我們再看看其他重要的屬性珍坊。

1 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

2

3 // 這里 COUNT_BITS 設(shè)置為 29(32-3),意味著前三位用于存放線程狀態(tài)正罢,后29位用于存放線程數(shù)

4 private static final int COUNT_BITS = Integer.SIZE - 3;

5

6 // 000 11111111111111111111111111111

7 // 這里得到的是 29 個 1阵漏,也就是說線程池的最大線程數(shù)是 2^29-1=536870911

8 // 以我們現(xiàn)在計(jì)算機(jī)的實(shí)際情況,這個數(shù)量還是夠用的

9 private static final int CAPACITY? = (1 << COUNT_BITS) - 1;

10

11 // 我們說了翻具,線程池的狀態(tài)存放在高 3 位中

12 // 運(yùn)算結(jié)果為 111跟29個0:111 00000000000000000000000000000

13 private static final int RUNNING? ? = -1 << COUNT_BITS;

14 // 000 00000000000000000000000000000

15 private static final int SHUTDOWN? =? 0 << COUNT_BITS;

16 // 001 00000000000000000000000000000

17 private static final int STOP? ? ? =? 1 << COUNT_BITS;

18 // 010 00000000000000000000000000000

19 private static final int TIDYING? ? =? 2 << COUNT_BITS;

20 // 011 00000000000000000000000000000

21 private static final int TERMINATED =? 3 << COUNT_BITS;

22

23 // 將整數(shù) c 的低 29 位修改為 0履怯,就得到了線程池的狀態(tài)

24 private static int runStateOf(int c)? ? { return c & ~CAPACITY; }

25 // 將整數(shù) c 的高 3 為修改為 0,就得到了線程池中的線程數(shù)

26 private static int workerCountOf(int c)? { return c & CAPACITY; }

27

28 private static int ctlOf(int rs, int wc) { return rs | wc; }

29

30 private static boolean runStateLessThan(int c, int s) {

31? ? return c < s;

32 }

33

34 private static boolean runStateAtLeast(int c, int s) {

35? ? return c >= s;

36 }

37

38 private static boolean isRunning(int c) {

39? ? return c < SHUTDOWN;

40 }

在這里裆泳,介紹下線程池中的各個狀態(tài)和狀態(tài)變化的轉(zhuǎn)換過程:

RUNNING:這個沒什么好說的叹洲,這是最正常的狀態(tài):接受新的任務(wù),處理等待隊(duì)列中的任務(wù)

SHUTDOWN:不接受新的任務(wù)提交工禾,但是會繼續(xù)處理等待隊(duì)列中的任務(wù)

STOP:不接受新的任務(wù)提交运提,不再處理等待隊(duì)列中的任務(wù),中斷正在執(zhí)行任務(wù)的線程

TIDYING:所有的任務(wù)都銷毀了闻葵,workCount 為 0民泵。線程池的狀態(tài)在轉(zhuǎn)換為 TIDYING 狀態(tài)時,會執(zhí)行鉤子方法 terminated()

TERMINATED:terminated() 方法結(jié)束后槽畔,線程池的狀態(tài)就會變成這個

在此我向大家推薦一個架構(gòu)學(xué)習(xí)交流圈:830478757 ?幫助突破瓶頸 提升思維能力

看了這幾種狀態(tài)的介紹栈妆,讀者大體也可以猜到十之八九的狀態(tài)轉(zhuǎn)換了,各個狀態(tài)的轉(zhuǎn)換過程有以下幾種:

RUNNING -> SHUTDOWN:當(dāng)調(diào)用了 shutdown() 后厢钧,會發(fā)生這個狀態(tài)轉(zhuǎn)換鳞尔,這也是最重要的

(RUNNING or SHUTDOWN) -> STOP:當(dāng)調(diào)用 shutdownNow() 后,會發(fā)生這個狀態(tài)轉(zhuǎn)換坏快,這下要清楚 shutDown() 和 shutDownNow() 的區(qū)別了

SHUTDOWN -> TIDYING:當(dāng)任務(wù)隊(duì)列和線程池都清空后,會由 SHUTDOWN 轉(zhuǎn)換為 TIDYING

STOP -> TIDYING:當(dāng)任務(wù)隊(duì)列清空后憎夷,發(fā)生這個轉(zhuǎn)換

TIDYING -> TERMINATED:這個前面說了莽鸿,當(dāng) terminated() 方法結(jié)束后

另外,我們還要看看一個內(nèi)部類 Worker拾给,因?yàn)?Doug Lea 把線程池中的線程包裝成了一個個 Worker祥得,翻譯成工人,就是線程池中做任務(wù)的線程蒋得。所以到這里级及,我們知道任務(wù)是 Runnable(內(nèi)部叫 task 或 command),線程是 Worker额衙。

?

1 private final class Worker

2? ? extends AbstractQueuedSynchronizer

3? ? implements Runnable{

4? ? private static final long serialVersionUID = 6138294804551838833L;

5

6? ? // 這個是真正的線程饮焦,任務(wù)靠你啦

7? ? final Thread thread;

8

9? ? // 前面說了怕吴,這里的 Runnable 是任務(wù)。為什么叫 firstTask县踢?因?yàn)樵趧?chuàng)建線程的時候转绷,如果同時指定了

10? ? // 這個線程起來以后需要執(zhí)行的第一個任務(wù),那么第一個任務(wù)就是存放在這里的(線程可不止執(zhí)行這一個任務(wù))

11? ? // 當(dāng)然了硼啤,也可以為 null议经,這樣線程起來了,自己到任務(wù)隊(duì)列(BlockingQueue)中取任務(wù)(getTask 方法)就行了

12? ? Runnable firstTask;

13

14? ? // 用于存放此線程完全的任務(wù)數(shù)谴返,注意了煞肾,這里用了 volatile,保證可見性

15? ? volatile long completedTasks;

16

17? ? // Worker 只有這一個構(gòu)造方法嗓袱,傳入 firstTask样傍,也可以傳 null

18? ? Worker(Runnable firstTask) {

19? ? ? ? setState(-1); // inhibit interrupts until runWorker

20? ? ? ? this.firstTask = firstTask;

21? ? ? ? // 調(diào)用 ThreadFactory 來創(chuàng)建一個新的線程,這里創(chuàng)建的線程到時候用來執(zhí)行任務(wù)

22? ? ? ? this.thread = getThreadFactory().newThread(this);

23? ? }

24

25? ? // 這里調(diào)用了外部類的 runWorker 方法

26? ? public void run() {

27? ? ? ? runWorker(this);

28? ? }

29

30? ? ...

31 }

有了上面的這些基礎(chǔ)后,我們終于可以看看 ThreadPoolExecutor 的 execute 方法了炕横,前面源碼分析的時候也說了胚泌,各種方法都最終依賴于 execute 方法:

1 public void execute(Runnable command) {

2? ? if (command == null)

3? ? ? ? throw new NullPointerException();

4

5? ? // 前面說的那個表示 "線程池狀態(tài)" 和 "線程數(shù)" 的整數(shù)

6? ? int c = ctl.get();

7

8? ? // 如果當(dāng)前線程數(shù)少于核心線程數(shù),那么直接添加一個 worker 來執(zhí)行任務(wù)逼肯,

9? ? // 創(chuàng)建一個新的線程耸黑,并把當(dāng)前任務(wù) command 作為這個線程的第一個任務(wù)(firstTask)

10? ? if (workerCountOf(c) < corePoolSize) {

11? ? ? ? // 添加任務(wù)成功,那么就結(jié)束了篮幢。提交任務(wù)嘛大刊,線程池已經(jīng)接受了這個任務(wù),這個方法也就可以返回了

12? ? ? ? // 至于執(zhí)行的結(jié)果三椿,到時候會包裝到 FutureTask 中缺菌。

13? ? ? ? // 這里的true代表當(dāng)前線程數(shù)小于corePoolSize,表示以corePoolSize為線程數(shù)界限

14? ? ? ? if (addWorker(command, true))

15? ? ? ? ? ? return;

16? ? ? ? c = ctl.get();

17? ? }

18? ? // 到這里說明搜锰,要么當(dāng)前線程數(shù)大于等于核心線程數(shù)伴郁,要么剛剛 addWorker 失敗了

19? ? // 如果線程池處于 RUNNING 狀態(tài),把這個任務(wù)添加到任務(wù)隊(duì)列 workQueue 中

20? ? if (isRunning(c) && workQueue.offer(command)) {

21? ? ? ? int recheck = ctl.get();

22? ? ? ? // 如果線程池已不處于 RUNNING 狀態(tài)蛋叼,那么移除已經(jīng)入隊(duì)的這個任務(wù)焊傅,并且執(zhí)行拒絕策略

23? ? ? ? if (! isRunning(recheck) && remove(command))

24? ? ? ? ? ? reject(command);

25? ? ? ? else if (workerCountOf(recheck) == 0)

26? ? ? ? ? ? addWorker(null, false);

27? ? }

28? ? // 如果 workQueue 隊(duì)列滿了,那么進(jìn)入到這個分支

29? ? // 這里的false代表當(dāng)前線程數(shù)大于corePoolSize狈涮,表示以 maximumPoolSize 為界創(chuàng)建新的 worker

30? ? // 如果失敗狐胎,說明當(dāng)前線程數(shù)已經(jīng)達(dá)到 maximumPoolSize,執(zhí)行拒絕策略

31? ? else if (!addWorker(command, false))

32? ? ? ? reject(command);

33 }

?我們可以看看大體的執(zhí)行流程


這個方法非常重要 addWorker(Runnable firstTask, boolean core) 方法歌馍,我們看看它是怎么創(chuàng)建新的線程的:

1 // 第一個參數(shù)是準(zhǔn)備提交給這個線程執(zhí)行的任務(wù)握巢,之前說了,可以為 null

2 // 第二個參數(shù)為 true 代表使用核心線程數(shù) corePoolSize 作為創(chuàng)建線程的界線松却,也就說創(chuàng)建這個線程的時候暴浦,

3 //? ? ? ? 如果線程池中的線程總數(shù)已經(jīng)達(dá)到 corePoolSize溅话,那么返回false

4 //? ? ? ? 如果是 false,代表使用最大線程數(shù) maximumPoolSize 作為界線肉渴,線程池中的線程總數(shù)已經(jīng)達(dá)到 maximumPoolSize公荧,那么返回false

5 private boolean addWorker(Runnable firstTask, boolean core) {

6? ? retry:

7? ? for (;;) {

8? ? ? ? int c = ctl.get();

9? ? ? ? int rs = runStateOf(c);

10

11? ? ? ? // 如果線程池已關(guān)閉,并滿足以下條件之一同规,那么不創(chuàng)建新的 worker:

12? ? ? ? // 1. 線程池狀態(tài)大于 SHUTDOWN循狰,其實(shí)也就是 STOP, TIDYING, 或 TERMINATED

13? ? ? ? // 2. firstTask != null

14? ? ? ? // 3. workQueue.isEmpty()

15? ? ? ? if (rs >= SHUTDOWN &&

16? ? ? ? ? ? ! (rs == SHUTDOWN &&

17? ? ? ? ? ? ? ? firstTask == null &&

18? ? ? ? ? ? ? ? ! workQueue.isEmpty()))

19? ? ? ? ? ? return false;

20

21? ? ? ? for (;;) {

22? ? ? ? ? ? int wc = workerCountOf(c);

23? ? ? ? ? ? //這里就是通過core參數(shù)對當(dāng)前線程數(shù)的判斷

24? ? ? ? ? ? if (wc >= CAPACITY ||

25? ? ? ? ? ? ? ? wc >= (core ? corePoolSize : maximumPoolSize))

26? ? ? ? ? ? ? ? return false;

27? ? ? ? ? ? if (compareAndIncrementWorkerCount(c))

28? ? ? ? ? ? ? ? break retry;

29? ? ? ? ? ? c = ctl.get();

30? ? ? ? ? ? if (runStateOf(c) != rs)

31? ? ? ? ? ? ? ? continue retry;

32? ? ? ? ? ? // else CAS failed due to workerCount change; retry inner loop

33? ? ? ? }

34? ? }

35

36? ? /*

37? ? ? * 到這里,我們認(rèn)為在當(dāng)前這個時刻券勺,可以開始創(chuàng)建線程來執(zhí)行任務(wù)了绪钥,

38? ? ? */

39

40? ? // worker 是否已經(jīng)啟動

41? ? boolean workerStarted = false;

42? ? // 是否已將這個 worker 添加到 workers 這個 HashSet 中

43? ? boolean workerAdded = false;

44? ? Worker w = null;

45? ? try {

46? ? ? ? final ReentrantLock mainLock = this.mainLock;

47? ? ? ? // 把 firstTask 傳給 worker 的構(gòu)造方法

48? ? ? ? w = new Worker(firstTask);

49? ? ? ? // 取 worker 中的線程對象,之前說了关炼,Worker的構(gòu)造方法會調(diào)用 ThreadFactory 來創(chuàng)建一個新的線程

50? ? ? ? final Thread t = w.thread;

51? ? ? ? if (t != null) {

52? ? ? ? ? ? // 這個是整個類的全局鎖程腹,因?yàn)殛P(guān)閉一個線程池需要這個鎖,至少我持有鎖的期間儒拂,線程池不會被關(guān)閉

53? ? ? ? ? ? mainLock.lock();

54? ? ? ? ? ? try {

55

56? ? ? ? ? ? ? ? int c = ctl.get();

57? ? ? ? ? ? ? ? int rs = runStateOf(c);

58

59? ? ? ? ? ? ? ? // 小于 SHUTTDOWN 那就是 RUNNING

60? ? ? ? ? ? ? ? // 如果等于 SHUTDOWN寸潦,前面說了,不接受新的任務(wù)社痛,但是會繼續(xù)執(zhí)行等待隊(duì)列中的任務(wù)

61? ? ? ? ? ? ? ? if (rs < SHUTDOWN ||

62? ? ? ? ? ? ? ? ? ? (rs == SHUTDOWN && firstTask == null)) {

63? ? ? ? ? ? ? ? ? ? // worker 里面的 thread 可不能是已經(jīng)啟動的

64? ? ? ? ? ? ? ? ? ? if (t.isAlive())

65? ? ? ? ? ? ? ? ? ? ? ? throw new IllegalThreadStateException();

66? ? ? ? ? ? ? ? ? ? // 加到 workers 這個 HashSet 中

67? ? ? ? ? ? ? ? ? ? workers.add(w);

68? ? ? ? ? ? ? ? ? ? int s = workers.size();

69? ? ? ? ? ? ? ? ? ? // largestPoolSize 用于記錄 workers 中的個數(shù)的最大值

70? ? ? ? ? ? ? ? ? ? // 因?yàn)?workers 是不斷增加減少的见转,通過這個值可以知道線程池的大小曾經(jīng)達(dá)到的最大值

71? ? ? ? ? ? ? ? ? ? if (s > largestPoolSize)

72? ? ? ? ? ? ? ? ? ? ? ? largestPoolSize = s;

73? ? ? ? ? ? ? ? ? ? workerAdded = true;

74? ? ? ? ? ? ? ? }

75? ? ? ? ? ? } finally {

76? ? ? ? ? ? ? ? mainLock.unlock();

77? ? ? ? ? ? }

78? ? ? ? ? ? // 添加成功的話,啟動這個線程

79? ? ? ? ? ? if (workerAdded) {

80? ? ? ? ? ? ? ? // 啟動線程蒜哀,最重要的就是這里斩箫,下面我們會講解如何執(zhí)行任務(wù)

81? ? ? ? ? ? ? ? t.start();

82? ? ? ? ? ? ? ? workerStarted = true;

83? ? ? ? ? ? }

84? ? ? ? }

85? ? } finally {

86? ? ? ? // 如果線程沒有啟動,需要做一些清理工作撵儿,如前面 workCount 加了 1乘客,將其減掉

87? ? ? ? if (! workerStarted)

88? ? ? ? ? ? addWorkerFailed(w);

89? ? }

90? ? // 返回線程是否啟動成功

91? ? return workerStarted;

92 }

上面第81行代碼處已經(jīng)啟動了線程,w = new Worker(firstTask);??t = w.thread淀歇,我們接著看看Worker這個類

1 private final class Worker

2? ? extends AbstractQueuedSynchronizer

3? ? implements Runnable{

4? ? private static final long serialVersionUID = 6138294804551838833L;

5? ? final Thread thread;

6? ? Runnable firstTask;

7? ? volatile long completedTasks;

8

9? ? // Worker 只有這一個構(gòu)造方法易核,傳入 firstTask

10? ? Worker(Runnable firstTask) {

11? ? ? ? setState(-1); // inhibit interrupts until runWorker

12? ? ? ? this.firstTask = firstTask;

13? ? ? ? // 調(diào)用 ThreadFactory 來創(chuàng)建一個新的線程,這里創(chuàng)建的線程到時候用來執(zhí)行任務(wù)

14? ? ? ? // 我們發(fā)現(xiàn)創(chuàng)建線程的時候傳入的值是this,我們知道創(chuàng)建線程可以通過繼承Runnable的方法浪默,

15? ? ? ? // Worker繼承了Runnable牡直,并且下面重寫了run()方法

16? ? ? ? this.thread = getThreadFactory().newThread(this);

17? ? }

18

19? ? // 由上面創(chuàng)建線程時傳入的this,上面的thread啟動后,會執(zhí)行這里的run()方法浴鸿,并且此時runWorker傳入的也是this

20? ? public void run() {

21? ? ? ? runWorker(this);

22? ? }

23 }

繼續(xù)往下看 runWorker 方法:

1 // 此方法由 worker 線程啟動后調(diào)用井氢,這里用一個 while 循環(huán)來不斷地從等待隊(duì)列中獲取任務(wù)并執(zhí)行

2 // 前面說了弦追,worker 在初始化的時候岳链,可以指定 firstTask,那么第一個任務(wù)也就可以不需要從隊(duì)列中獲取

3 final void runWorker(Worker w) {

4? ? Thread wt = Thread.currentThread();

5? ? // 該線程的第一個任務(wù)(如果有的話)

6? ? Runnable task = w.firstTask;

7? ? w.firstTask = null;

8? ? w.unlock(); // allow interrupts

9? ? boolean completedAbruptly = true;

10? ? try {

11? ? ? ? // 循環(huán)調(diào)用 getTask 獲取任務(wù)

12? ? ? ? while (task != null || (task = getTask()) != null) {

13? ? ? ? ? ? w.lock();? ? ? ? ?

14? ? ? ? ? ? // 如果線程池狀態(tài)大于等于 STOP劲件,那么意味著該線程也要中斷

15? ? ? ? ? ? if ((runStateAtLeast(ctl.get(), STOP) ||

16? ? ? ? ? ? ? ? ? (Thread.interrupted() &&

17? ? ? ? ? ? ? ? ? runStateAtLeast(ctl.get(), STOP))) &&

18? ? ? ? ? ? ? ? !wt.isInterrupted())

19? ? ? ? ? ? ? ? wt.interrupt();

20? ? ? ? ? ? try {

21? ? ? ? ? ? ? ? beforeExecute(wt, task);

22? ? ? ? ? ? ? ? Throwable thrown = null;

23? ? ? ? ? ? ? ? try {

24? ? ? ? ? ? ? ? ? ? // 到這里終于可以執(zhí)行任務(wù)了掸哑,這里是最重要的约急,task是什么?是Worker 中的firstTask屬性

25? ? ? ? ? ? ? ? ? ? // 也就是上面我們使用示例里面的 new MyRunnable()實(shí)例苗分,這里就是真正的執(zhí)行run方法里面的代碼

26? ? ? ? ? ? ? ? ? ? task.run();

27? ? ? ? ? ? ? ? } catch (RuntimeException x) {

28? ? ? ? ? ? ? ? ? ? thrown = x; throw x;

29? ? ? ? ? ? ? ? } catch (Error x) {

30? ? ? ? ? ? ? ? ? ? thrown = x; throw x;

31? ? ? ? ? ? ? ? } catch (Throwable x) {

32? ? ? ? ? ? ? ? ? ? thrown = x; throw new Error(x);

33? ? ? ? ? ? ? ? } finally {

34? ? ? ? ? ? ? ? ? ? afterExecute(task, thrown);

35? ? ? ? ? ? ? ? }

36? ? ? ? ? ? } finally {

37? ? ? ? ? ? ? ? // 一個任務(wù)執(zhí)行完了厌蔽,這個線程還可以復(fù)用,接著去隊(duì)列中拉取任務(wù)執(zhí)行

38? ? ? ? ? ? ? ? // 置空 task摔癣,準(zhǔn)備 getTask 獲取下一個任務(wù)

39? ? ? ? ? ? ? ? task = null;

40? ? ? ? ? ? ? ? // 累加完成的任務(wù)數(shù)

41? ? ? ? ? ? ? ? w.completedTasks++;

42? ? ? ? ? ? ? ? // 釋放掉 worker 的獨(dú)占鎖

43? ? ? ? ? ? ? ? w.unlock();

44? ? ? ? ? ? }

45? ? ? ? }

46? ? ? ? completedAbruptly = false;

47? ? } finally {

48? ? ? ? // 如果到這里奴饮,需要執(zhí)行線程關(guān)閉:

49? ? ? ? // 說明 getTask 返回 null,也就是超過corePoolSize的線程過了超時時間還沒有獲取到任務(wù)择浊,也就是說戴卜,這個 worker 的使命結(jié)束了,執(zhí)行關(guān)閉

50? ? ? ? processWorkerExit(w, completedAbruptly);

51? ? }

52 }

我們看看 getTask() 是怎么獲取任務(wù)的

1 // 此方法有三種可能:

2 // 1. 阻塞直到獲取到任務(wù)返回琢岩。我們知道投剥,默認(rèn) corePoolSize 之內(nèi)的線程是不會被回收的,

3 //? ? ? 它們會一直等待任務(wù)

4 // 2. 超時退出担孔。keepAliveTime 起作用的時候江锨,也就是如果這么多時間內(nèi)都沒有任務(wù),那么應(yīng)該執(zhí)行關(guān)閉

5 // 3. 如果發(fā)生了以下條件糕篇,此方法必須返回 null:

6 //? ? - 池中有大于 maximumPoolSize 個 workers 存在(通過調(diào)用 setMaximumPoolSize 進(jìn)行設(shè)置)

7 //? ? - 線程池處于 SHUTDOWN啄育,而且 workQueue 是空的,前面說了娩缰,這種不再接受新的任務(wù)

8 //? ? - 線程池處于 STOP灸撰,不僅不接受新的線程,連 workQueue 中的線程也不再執(zhí)行

9 private Runnable getTask() {

10? ? boolean timedOut = false; // Did the last poll() time out?

11

12? ? retry:

13? ? for (;;) {

14? ? ? ? int c = ctl.get();

15? ? ? ? int rs = runStateOf(c);

16? ? ? ? // 兩種可能

17? ? ? ? // 1. rs == SHUTDOWN && workQueue.isEmpty()

18? ? ? ? // 2. rs >= STOP

19? ? ? ? if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {

20? ? ? ? ? ? // CAS 操作拼坎,減少工作線程數(shù)

21? ? ? ? ? ? decrementWorkerCount();

22? ? ? ? ? ? return null;

23? ? ? ? }

24

25? ? ? ? boolean timed;? ? ? // Are workers subject to culling?

26? ? ? ? for (;;) {

27? ? ? ? ? ? int wc = workerCountOf(c);

28? ? ? ? ? ? // 允許核心線程數(shù)內(nèi)的線程回收浮毯,或當(dāng)前線程數(shù)超過了核心線程數(shù),那么有可能發(fā)生超時關(guān)閉

29? ? ? ? ? ? timed = allowCoreThreadTimeOut || wc > corePoolSize;

30? ? ? ? ? ? if (wc <= maximumPoolSize && ! (timedOut && timed))

31? ? ? ? ? ? ? ? break;

32? ? ? ? ? ? if (compareAndDecrementWorkerCount(c))

33? ? ? ? ? ? ? ? return null;

34? ? ? ? ? ? c = ctl.get();? // Re-read ctl

35? ? ? ? ? ? // compareAndDecrementWorkerCount(c) 失敗泰鸡,線程池中的線程數(shù)發(fā)生了改變

36? ? ? ? ? ? if (runStateOf(c) != rs)

37? ? ? ? ? ? ? ? continue retry;

38? ? ? ? ? ? // else CAS failed due to workerCount change; retry inner loop

39? ? ? ? }

40? ? ? ? // wc <= maximumPoolSize 同時沒有超時

41? ? ? ? try {

42? ? ? ? ? ? // 到 workQueue 中獲取任務(wù)

43? ? ? ? ? ? // 如果timed=wc > corePoolSize=false,我們知道核心線程數(shù)之內(nèi)的線程永遠(yuǎn)不會銷毀债蓝,則執(zhí)行workQueue.take();我前面文章中講過,take()方法是阻塞方法盛龄,如果隊(duì)里中有任務(wù)則取到任務(wù)饰迹,如果沒有任務(wù),則一直阻塞在這里知道有任務(wù)被喚醒余舶。

44? ? ? ? ? ? //如果timed=wc > corePoolSize=true,這里將執(zhí)行超時策略啊鸭,poll(keepAliveTime, TimeUnit.NANOSECONDS)會阻塞keepAliveTime這么長時間,沒超時就返回任務(wù)匿值,超時則返回null.

45? ? ? ? ? ? Runnable r = timed ?

46? ? ? ? ? ? ? ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

47? ? ? ? ? ? ? ? workQueue.take();

48? ? ? ? ? ? if (r != null)

49? ? ? ? ? ? ? ? return r;

50? ? ? ? ? ? timedOut = true;

51? ? ? ? } catch (InterruptedException retry) {

52? ? ? ? ? ? // 如果此 worker 發(fā)生了中斷赠制,采取的方案是重試

53? ? ? ? ? ? // 解釋下為什么會發(fā)生中斷,這個讀者要去看 setMaximumPoolSize 方法挟憔,

54? ? ? ? ? ? // 如果開發(fā)者將 maximumPoolSize 調(diào)小了钟些,導(dǎo)致其小于當(dāng)前的 workers 數(shù)量烟号,

55? ? ? ? ? ? // 那么意味著超出的部分線程要被關(guān)閉。重新進(jìn)入 for 循環(huán)政恍,自然會有部分線程會返回 null

56? ? ? ? ? ? timedOut = false;

57? ? ? ? }

58? ? }

59 }

到這里汪拥,基本上也說完了整個流程,讀者這個時候應(yīng)該回到 execute(Runnable command) 方法篙耗,有兩種情況會調(diào)用 reject(command) 來處理任務(wù)迫筑,因?yàn)榘凑照5牧鞒蹋€程池此時不能接受這個任務(wù)宗弯,所以需要執(zhí)行我們的拒絕策略铣焊。接下來,我們說一說 ThreadPoolExecutor 中的拒絕策略罕伯。

1 final void reject(Runnable command) {

2? ? // 執(zhí)行拒絕策略

3? ? handler.rejectedExecution(command, this);

4 }

此處的 handler 我們需要在構(gòu)造線程池的時候就傳入這個參數(shù)曲伊,它是 RejectedExecutionHandler 的實(shí)例。

RejectedExecutionHandler 在 ThreadPoolExecutor 中有四個已經(jīng)定義好的實(shí)現(xiàn)類可供我們直接使用追他,當(dāng)然坟募,我們也可以實(shí)現(xiàn)自己的策略,不過一般也沒有必要邑狸。

1 // 只要線程池沒有被關(guān)閉懈糯,那么由提交任務(wù)的線程自己來執(zhí)行這個任務(wù)。

2 public static class CallerRunsPolicy implements RejectedExecutionHandler {

3? ? public CallerRunsPolicy() { }

4? ? public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

5? ? ? ? if (!e.isShutdown()) {

6? ? ? ? ? ? r.run();

7? ? ? ? }

8? ? }

9 }

10

11 // 不管怎樣单雾,直接拋出 RejectedExecutionException 異常

12 // 這個是默認(rèn)的策略赚哗,如果我們構(gòu)造線程池的時候不傳相應(yīng)的 handler 的話,那就會指定使用這個

??????在此我向大家推薦一個架構(gòu)學(xué)習(xí)交流圈:830478757 ?幫助突破瓶頸 提升思維能力

13 public static class AbortPolicy implements RejectedExecutionHandler {

14? ? public AbortPolicy() { }

15? ? public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

16? ? ? ? throw new RejectedExecutionException("Task " + r.toString() +

17? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? " rejected from " +

18? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? e.toString());

19? ? }

20 }

21

22 // 不做任何處理硅堆,直接忽略掉這個任務(wù)

23 public static class DiscardPolicy implements RejectedExecutionHandler {

24? ? public DiscardPolicy() { }

25? ? public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

26? ? }

27 }

28

29 // 這個相對霸道一點(diǎn)屿储,如果線程池沒有被關(guān)閉的話,

30 // 把隊(duì)列隊(duì)頭的任務(wù)(也就是等待了最長時間的)直接扔掉渐逃,然后提交這個任務(wù)到等待隊(duì)列中

31 public static class DiscardOldestPolicy implements RejectedExecutionHandler {

32? ? public DiscardOldestPolicy() { }

33? ? public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

34? ? ? ? if (!e.isShutdown()) {

35? ? ? ? ? ? e.getQueue().poll();

36? ? ? ? ? ? e.execute(r);

37? ? ? ? }

38? ? }

39 }

到這里够掠,ThreadPoolExecutor 算是分析得差不多了

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 序言:七十年代末,一起剝皮案震驚了整個濱河市茄菊,隨后出現(xiàn)的幾起案子疯潭,更是在濱河造成了極大的恐慌,老刑警劉巖面殖,帶你破解...
    沈念sama閱讀 217,185評論 6 503
  • 序言:濱河連續(xù)發(fā)生了三起死亡事件竖哩,死亡現(xiàn)場離奇詭異,居然都是意外死亡脊僚,警方通過查閱死者的電腦和手機(jī)相叁,發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 92,652評論 3 393
  • 文/潘曉璐 我一進(jìn)店門,熙熙樓的掌柜王于貴愁眉苦臉地迎上來,“玉大人钝荡,你說我怎么就攤上這事〔俺模” “怎么了埠通?”我有些...
    開封第一講書人閱讀 163,524評論 0 353
  • 文/不壞的土叔 我叫張陵,是天一觀的道長逛犹。 經(jīng)常有香客問我端辱,道長,這世上最難降的妖魔是什么虽画? 我笑而不...
    開封第一講書人閱讀 58,339評論 1 293
  • 正文 為了忘掉前任舞蔽,我火速辦了婚禮,結(jié)果婚禮上码撰,老公的妹妹穿的比我還像新娘渗柿。我一直安慰自己,他們只是感情好脖岛,可當(dāng)我...
    茶點(diǎn)故事閱讀 67,387評論 6 391
  • 文/花漫 我一把揭開白布朵栖。 她就那樣靜靜地躺著,像睡著了一般柴梆。 火紅的嫁衣襯著肌膚如雪陨溅。 梳的紋絲不亂的頭發(fā)上,一...
    開封第一講書人閱讀 51,287評論 1 301
  • 那天绍在,我揣著相機(jī)與錄音门扇,去河邊找鬼。 笑死偿渡,一個胖子當(dāng)著我的面吹牛臼寄,可吹牛的內(nèi)容都是我干的。 我是一名探鬼主播溜宽,決...
    沈念sama閱讀 40,130評論 3 418
  • 文/蒼蘭香墨 我猛地睜開眼脯厨,長吁一口氣:“原來是場噩夢啊……” “哼!你這毒婦竟也來了坑质?” 一聲冷哼從身側(cè)響起合武,我...
    開封第一講書人閱讀 38,985評論 0 275
  • 序言:老撾萬榮一對情侶失蹤,失蹤者是張志新(化名)和其女友劉穎涡扼,沒想到半個月后稼跳,有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體,經(jīng)...
    沈念sama閱讀 45,420評論 1 313
  • 正文 獨(dú)居荒郊野嶺守林人離奇死亡吃沪,尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點(diǎn)故事閱讀 37,617評論 3 334
  • 正文 我和宋清朗相戀三年汤善,在試婚紗的時候發(fā)現(xiàn)自己被綠了。 大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
    茶點(diǎn)故事閱讀 39,779評論 1 348
  • 序言:一個原本活蹦亂跳的男人離奇死亡红淡,死狀恐怖不狮,靈堂內(nèi)的尸體忽然破棺而出,到底是詐尸還是另有隱情在旱,我是刑警寧澤摇零,帶...
    沈念sama閱讀 35,477評論 5 345
  • 正文 年R本政府宣布,位于F島的核電站桶蝎,受9級特大地震影響驻仅,放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜登渣,卻給世界環(huán)境...
    茶點(diǎn)故事閱讀 41,088評論 3 328
  • 文/蒙蒙 一噪服、第九天 我趴在偏房一處隱蔽的房頂上張望。 院中可真熱鬧胜茧,春花似錦粘优、人聲如沸。這莊子的主人今日做“春日...
    開封第一講書人閱讀 31,716評論 0 22
  • 文/蒼蘭香墨 我抬頭看了看天上的太陽。三九已至芬位,卻和暖如春无拗,著一層夾襖步出監(jiān)牢的瞬間,已是汗流浹背昧碉。 一陣腳步聲響...
    開封第一講書人閱讀 32,857評論 1 269
  • 我被黑心中介騙來泰國打工英染, 沒想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留,地道東北人被饿。 一個月前我還...
    沈念sama閱讀 47,876評論 2 370
  • 正文 我出身青樓四康,卻偏偏與公主長得像,于是被迫代替她去往敵國和親狭握。 傳聞我的和親對象是個殘疾皇子闪金,可洞房花燭夜當(dāng)晚...
    茶點(diǎn)故事閱讀 44,700評論 2 354

推薦閱讀更多精彩內(nèi)容