📝 Writing docs.

dunwu · dunwu · commit 93ed4977d468 · 2018-05-24T17:41:55.000+08:00
diff --git a/docs/concurrent/线程基础.md b/docs/concurrent/线程基础.md
@@ -12,24 +12,27 @@ tags:
 
 <!-- TOC depthFrom:2 depthTo:3 -->
 
-* [线程生命周期](#线程生命周期)
-* [创建线程](#创建线程)
-    * [继承 Thread 类](#继承-thread-类)
-    * [实现 Runnable 接口](#实现-runnable-接口)
-    * [通过 Callable 接口和 Future 接口](#通过-callable-接口和-future-接口)
-    * [三种创建线程方式对比](#三种创建线程方式对比)
-* [Thread 中的重要方法](#thread-中的重要方法)
-    * [设置/获取线程名称](#设置获取线程名称)
-    * [判断线程是否启动](#判断线程是否启动)
-    * [中断线程](#中断线程)
-    * [守护线程](#守护线程)
-    * [设置/获取线程优先级](#设置获取线程优先级)
-    * [线程的强制执行](#线程的强制执行)
-    * [线程的休眠](#线程的休眠)
-    * [线程的礼让](#线程的礼让)
+* [线程简介](#线程简介)
+    * [什么是线程](#什么是线程)
+    * [线程生命周期](#线程生命周期)
+* [启动和终止线程](#启动和终止线程)
+    * [构造线程](#构造线程)
+        * [继承 Thread 类](#继承-thread-类)
+        * [实现 Runnable 接口](#实现-runnable-接口)
+        * [实现 Callable 接口](#实现-callable-接口)
+        * [三种创建线程方式对比](#三种创建线程方式对比)
+    * [Thread 中的重要方法](#thread-中的重要方法)
+        * [设置/获取线程名称](#设置获取线程名称)
+        * [判断线程是否启动](#判断线程是否启动)
+        * [中断线程](#中断线程)
+        * [守护线程](#守护线程)
+        * [设置/获取线程优先级](#设置获取线程优先级)
+        * [线程的强制执行](#线程的强制执行)
+        * [线程的休眠](#线程的休眠)
     * [线程的终止](#线程的终止)
-* [Object 中的并发方法](#object-中的并发方法)
+* [线程间通信](#线程间通信)
     * [wait/notify/notifyAll](#waitnotifynotifyall)
+    * [线程的礼让](#线程的礼让)
 * [FAQ](#faq)
     * [start() 和 run() 有什么区别？可以直接调用 Thread 类的 run() 方法么？](#start-和-run-有什么区别可以直接调用-thread-类的-run-方法么)
     * [sleep()、yield()、join() 方法有什么区别？为什么 sleep()和 yield()方法是静态的？](#sleepyieldjoin-方法有什么区别为什么-sleep和-yield方法是静态的)
@@ -42,11 +45,24 @@ tags:
 
 <!-- /TOC -->
 
-## 线程生命周期
+## 线程简介
+
+### 什么是线程
+
+现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。
+
+### 线程生命周期
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/thread-state.png">
+</p>
+
+线程的生命周期有 6 种不同的状态，在给定的一个时刻，线程只能处于其中的一个状态。
+
+以下是 6 种状态的说明，以及状态间的联系。
 
 * 开始(New)：如果创建 Thread 类的实例，但在调用 start() 方法之前，线程处于新状态。
 * 可运行(Runnable)：线程对象创建后，其他线程(比如 main 线程）调用了该对象的 start()方法。此状态意味着，线程已经准备好了，一旦被线程调度器分配了 CPU 时间片，就可以运行线程。
-* 运行(Running)：可运行状态(Runnable)的线程获得了 cpu 时间片（timeslice），执行程序代码。
 * 定时等待(Timed waiting)：定时等待是在指定等待时间内等待的线程状态。调用以下方法，线程会进入定时等待状态：
   * Thread.sleep(sleeptime)
   * Object.wait(timeout)
@@ -60,25 +76,25 @@ tags:
 * 阻塞(Blocked)：阻塞状态。线程阻塞的线程状态等待监视器锁定。处于阻塞状态的线程正在等待监视器锁定，以便在调用 Object.wait 之后输入同步块/方法或重新输入同步块/方法。
 * 终止(Terminated)：线程 run()、main() 方法执行结束，或者因异常退出了 run()方法，则该线程结束生命周期。死亡的线程不可再次复生。
 
-线程状态切换如下图所示：
+## 启动和终止线程
 
-<p align="center">
-  <img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/thread-states.png" alt="thread-states">
-</p>
+### 构造线程
 
-## 创建线程
+构造线程主要有三种方式
 
-创建线程主要有三种方式
+* 继承 `Thread` 类
+* 实现 `Runnable` 接口
+* 实现 `Callable` 接口
 
-* 继承 Thread 类
-* 实现 Runnable 接口
-* 通过 Callable 接口和 Future 接口
+#### 继承 Thread 类
 
-### 继承 Thread 类
+通过继承 Thread 类构造线程的步骤：
 
-* 定义 Thread 类的子类，并重写该类的 run 方法，该 run 方法的方法体就代表了线程要完成的任务。因此把 run()方法称为执行体。
+* 定义 Thread 类的子类，并重写该类的 run() 方法，该 run() 方法的方法体就代表了线程要完成的任务。因此把 run() 方法称为执行体。
 * 创建 Thread 子类的实例，即创建了线程对象。
-* 调用线程对象的 start()方法来启动该线程。
+* 调用线程对象的 start() 方法来启动该线程。
+
+示例：
 
 ```java
 public class ThreadDemo02 {
@@ -110,11 +126,15 @@ public class ThreadDemo02 {
 }
 ```
 
-### 实现 Runnable 接口
+#### 实现 Runnable 接口
+
+通过实现 Runnable 接口构造线程的步骤：
 
-* 定义 Runnable 接口的实现类，并重写该接口的 run()方法，该 run()方法的方法体同样是该线程的线程执行体。
+* 定义 Runnable 接口的实现类，并重写该接口的 run() 方法，该 run() 方法的方法体同样是该线程的线程执行体。
 * 创建 Runnable 实现类的实例，并依此实例作为 Thread 的 target 来创建 Thread 对象，该 Thread 对象才是真正的线程对象。
-* 调用线程对象的 start()方法来启动该线程。
+* 调用线程对象的 start() 方法来启动该线程。
+
+示例：
 
 ```java
 public class RunnableDemo {
@@ -147,12 +167,16 @@ public class RunnableDemo {
 }
 ```
 
-### 通过 Callable 接口和 Future 接口
+#### 实现 Callable 接口
 
-* 创建 Callable 接口的实现类，并实现 call()方法，该 call()方法将作为线程执行体，并且有返回值。
-* 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call()方法的返回值。
+通过实现 Callable 接口构造线程的步骤：
+
+* 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
+* 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
 * 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
-* 调用 FutureTask 对象的 get()方法来获得子线程执行结束后的返回值
+* 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
+
+示例：
 
 ```java
 public class CallableAndFutureDemo {
@@ -171,12 +195,12 @@ public class CallableAndFutureDemo {
 }
 ```
 
-### 三种创建线程方式对比
+#### 三种创建线程方式对比
 
-* 实现 Runnable 接口优于继承 Thread 类，因为实现接口更便于扩展；
-* 实现 Runnable 接口的线程没有返回值；而使用 Callable Future 方式可以让线程有返回值。
+* **实现 Runnable 接口优于继承 Thread 类**，因为实现接口方式更便于扩展类。
+* 实现 Runnable 接口的线程没有返回值；而**实现 Callable 接口的线程有返回值**。
 
-## Thread 中的重要方法
+### Thread 中的重要方法
 
 * `run` - 线程的执行实体。
 * `start` - 线程的启动方法。
@@ -189,7 +213,7 @@ public class CallableAndFutureDemo {
 * `Thread.sleep` - 使用 Thread.sleep() 方法即可实现休眠。
 * `Thread.yield` - 可以使用 Thread.yield() 方法将一个线程的操作暂时让给其他线程执行。
 
-### 设置/获取线程名称
+#### 设置/获取线程名称
 
 在 Thread 类中可以通过 `setName()`、 `getName()` 来设置、获取线程名称。
 
@@ -217,7 +241,7 @@ public class ThreadNameDemo {
 }
 ```
 
-### 判断线程是否启动
+#### 判断线程是否启动
 
 在 Thread 类中可以通过 `isAlive()` 来判断线程是否启动。
 
@@ -250,7 +274,7 @@ public class ThreadAliveDemo {
 }
 ```
 
-### 中断线程
+#### 中断线程
 
 当一个线程运行时，另一个线程可以直接通过 `interrupt()` 方法中断其运行状态。
 
@@ -287,7 +311,7 @@ public class ThreadInterruptDemo {
 }
 ```
 
-### 守护线程
+#### 守护线程
 
 在 Java 程序中，只要前台有一个线程在运行，则整个 Java 进程就不会消失，所以此时可以设置一个守护线程，这样即使 Java 进程结束了，此守护线程依然会继续执行。可以使用 `setDaemon()` 方法设置线程为守护线程；可以使用 `isDaemon()` 方法判断线程是否为守护线程。
 
@@ -313,7 +337,7 @@ public class ThreadDaemonDemo {
 }
 ```
 
-### 设置/获取线程优先级
+#### 设置/获取线程优先级
 
 在 Java 中，所有线程在运行前都会保持在就绪状态，那么此时，哪个线程优先级高，哪个线程就有可能被先执行。
 
@@ -357,7 +381,7 @@ public class ThreadPriorityDemo {
 }
 ```
 
-### 线程的强制执行
+#### 线程的强制执行
 
 在线程操作中，可以使用 `join()` 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。
 
@@ -392,7 +416,7 @@ public class ThreadJoinDemo {
 }
 ```
 
-### 线程的休眠
+#### 线程的休眠
 
 直接使用 `Thread.sleep()` 方法即可实现休眠。
 
@@ -428,40 +452,6 @@ public class ThreadSleepDemo {
 }
 ```
 
-### 线程的礼让
-
-在线程操作中，可以使用 `Thread.yield()` 方法将一个线程的操作暂时让给其他线程执行。
-
-```java
-public class ThreadYieldDemo {
-
-    public static void main(String[] args) {
-        MyThread t = new MyThread();
-        new Thread(t, "线程A").start();
-        new Thread(t, "线程B").start();
-    }
-
-    static class MyThread implements Runnable {
-
-        @Override
-        public void run() {
-            for (int i = 0; i < 5; i++) {
-                try {
-                    Thread.sleep(1000);
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-                System.out.println(Thread.currentThread().getName() + "运行，i = " + i);
-                if (i == 2) {
-                    System.out.print("线程礼让：");
-                    Thread.yield();
-                }
-            }
-        }
-    }
-}
-```
-
 ### 线程的终止
 
 Thread 中的 stop 方法有缺陷，已废弃。
@@ -500,14 +490,16 @@ public class ThreadStopDemo02 {
 }
 ```
 
-## Object 中的并发方法
+## 线程间通信
+
+### wait/notify/notifyAll
+
+wait、notify、notifyAll 是 Object 类中的方法。
 
 * `wait` - 线程自动释放其占有的对象锁，并等待 notify。
 * `notify` - 唤醒一个正在 wait 当前对象锁的线程，并让它拿到对象锁。
 * `notifyAll` - 唤醒所有正在 wait 前对象锁的线程。
 
-### wait/notify/notifyAll
-
 生产者、消费者示例：
 
 ```java
@@ -589,6 +581,41 @@ public class ThreadWaitNotifyDemo02 {
 }
 ```
 
+
+### 线程的礼让
+
+在线程操作中，可以使用 `Thread.yield()` 方法将一个线程的操作暂时让给其他线程执行。
+
+```java
+public class ThreadYieldDemo {
+
+    public static void main(String[] args) {
+        MyThread t = new MyThread();
+        new Thread(t, "线程A").start();
+        new Thread(t, "线程B").start();
+    }
+
+    static class MyThread implements Runnable {
+
+        @Override
+        public void run() {
+            for (int i = 0; i < 5; i++) {
+                try {
+                    Thread.sleep(1000);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                System.out.println(Thread.currentThread().getName() + "运行，i = " + i);
+                if (i == 2) {
+                    System.out.print("线程礼让：");
+                    Thread.yield();
+                }
+            }
+        }
+    }
+}
+```
+
 ## FAQ
 
 ### start() 和 run() 有什么区别？可以直接调用 Thread 类的 run() 方法么？
@@ -661,7 +688,7 @@ Java 的每个对象中都有一个锁(monitor，也可以成为监视器) 并
 * [Java 并发编程实战](https://item.jd.com/10922250.html)
 * [Java 并发编程的艺术](https://item.jd.com/11740734.html)
 * https://stackoverflow.com/questions/27406200/visualvm-thread-states
-* https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.State.html
+* https://docs.oracle.com/javase/8/docs/api/index.html
 * https://www.journaldev.com/1037/java-thread-wait-notify-and-notifyall-example
 * http://www.importnew.com/14958.html
 * https://blog.csdn.net/xiangwanpeng/article/details/54972952
