2020-06-23 21:52:28

docs/62.md

@@ -24,7 +24,7 @@
 
 可以通过两种方式定义线程
 
-*   扩展 java.lang.Thread 类。
+*   扩展`java.lang.Thread`类。
 *   实现可运行接口。
 
 ### 扩展 Java 线程类：
@@ -43,11 +43,11 @@ System.out.println("Important job running in MyThread");
 
 但是这种方法的问题是类不能再扩展任何类。
 
-> **T** 他的运行方法可以在类中重载。 但是，JVM 仅考虑 run（）方法（不带参数）。 任何其他覆盖的方法都需要显式调用。
+> 线程的`run()`方法可以在类中重载。 但是，JVM 仅考虑`run()`方法（不带参数）。 任何其他覆盖的方法都需要显式调用。
 
-### 实现可运行的接口
+### 实现`Runnable`接口
 
-该类需要实现 runnable 接口，并且覆盖`run()`方法。以这种方式创建线程使您可以灵活地扩展所需的任何类。
+该类需要实现`Runnable`接口，并且覆盖`run()`方法。以这种方式创建线程使您可以灵活地扩展所需的任何类。
 
 ```java
 class MyRunnable implements Runnable {
@@ -61,26 +61,26 @@ System.out.println("Important job running in MyRunnable");
 
 ### 实例化线程：
 
-每个执行线程都以 Thread 类的实例开始。 无论如何，都需要在创建执行线程之前创建线程对象。
-两种情况下创建线程对象均不同。 如果扩展了 Thread 类，则可以使用 new 关键字直接启动类，因为它已经扩展了 Thread 类本身。
+每个执行线程都以`Thread`类的实例开始。 无论如何，都需要在创建执行线程之前创建线程对象。
+两种情况下创建线程对象均不同。 如果扩展了`Thread`类，则可以使用`new`关键字直接启动类，因为它已经扩展了`Thread`类本身。
 
 ```java
 MyThread t = new MyThread()
 ```
 
-如果实现 Runnable 接口。 首先创建的可运行类需要实例化。
+如果实现`Runnable`接口。 首先创建的可运行类需要实例化。
 
 ```java
 MyRunnable r = new MyRunnable();
 ```
 
-现在将此可运行对象传递给 Thread。
+现在将此可运行对象传递给`Thread`。
 
 ```java
 Thread t = new Thread(r);
 ```
 
-如果使用 no-arg 构造器创建线程，则该线程将调用其自己的 run（）。 这是在第一种情况下发生的（扩展 Thread 类），但是在 Runnable Thread 类的情况下，需要知道实现了可运行接口的类的 run 方法需要被调用，而不是 Thread 类的 run（）。 因此，我们需要将该类作为参数传递给 Thread。 单个可运行实例可以传递给多个 Thread 对象。
+如果使用无参构造器创建线程，则该线程将调用其自己的`run()`。 这是在第一种情况下发生的（扩展`Thread`类），但是在`Runnable`的情况下，需要知道实现了可运行接口的类的`run`方法需要被调用，而不是`Thread`类的`run()`。 因此，我们需要将该类作为参数传递给`Thread`。 单个可运行实例可以传递给多个`Thread`对象。
 
 ```java
 public class TestThreads {
@@ -99,9 +99,9 @@ Thread bat = new Thread(r);
 
 将相同的目标分配给多个线程意味着多个执行线程将运行同一作业（并且同一作业将执行多次）。
 
-> Thread 类本身实现了 Runnable。 （毕竟，它有一个我们要覆盖的 run（）方法。）这意味着您可以将 Thread 传递给另一个 Thread 的构造器。
+> `Thread`类本身实现了`Runnable`。 （毕竟，它有一个我们要覆盖的`run()`方法。）这意味着您可以将`Thread`传递给另一个`Thread`的构造器。
 
-## Thread 类中的重载构造器：
+## `Thread`类中的重载构造器：
 
 ```java
 Thread()
@@ -110,18 +110,19 @@ Thread(Runnable target, String name)
 Thread(String name)
 ```
 
-到目前为止，我们已经创建了一个 Thread 对象，并且它知道以 run（）方法的形式做什么。 但是到目前为止，它仍然是一个对象。 它没有调用栈。 换句话说，执行线程尚未启动。 仅当在线程上调用 start（）方法时，线程对象才会具有其栈。
+到目前为止，我们已经创建了一个`Thread`对象，并且它知道以`run()`方法的形式做什么。 但是到目前为止，它仍然是一个对象。 它没有调用栈。 换句话说，执行线程尚未启动。 仅当在线程上调用`start()`方法时，线程对象才会具有其栈。
 
 到目前为止，线程具有两种状态。
 
-*   新状态（已创建线程对象，但未调用 Start 方法）
+*   新状态（已创建线程对象，但未调用`Start`方法）
 *   可运行（活动）状态（调用启动方法）
 
-> 直接从 Java 代码调用 run（）方法意味着您正在调用方法，并且不会创建栈。
+> 直接从 Java 代码调用`run()`方法意味着您正在调用方法，并且不会创建栈。
 
-当线程处于可运行状态时，表示已创建线程，但尚未执行该线程的 run 方法，并且该线程正在等待轮到他。 选定线程后，线程的 run 方法将执行，该状态称为运行状态。
+当线程处于可运行状态时，表示已创建线程，但尚未执行该线程的`run`方法，并且该线程正在等待轮到他。 选定线程后，线程的`run`方法将执行，该状态称为运行状态。
 
 **线程调度程序**：
+
 线程调度程序是 JVM 的一部分，它决定在任何给定的时间应该运行哪个线程，并使线程退出运行状态 。 调度程序可以选择任何处于可运行状态的线程作为唯一正在运行的线程。 如果线程不处于可运行状态，则不能将其选择为当前正在运行的线程。 某种可能在某种程度上影响调度程序的方法（**注**：我们无法控制线程调度程序的行为）
 
 **这些方法来自线程类**
@@ -152,13 +153,13 @@ Thread(String name)
 *   等待/阻止/睡眠
 *   已死
 
-当线程的 run 方法完成执行时，该线程处于 Dead 状态。
+当线程的`run`方法完成执行时，该线程处于死亡状态。
 
-`sleep()`：sleep（）方法是 Thread 类的静态方法。 （它仍然必须乞求成为当前正在运行的线程）。 由于它仅在当前是静态方法，因此运行 Thread 将进入睡眠状态。 语法为：Thread.sleep（）
+`sleep()`：`sleep()`方法是`Thread`类的静态方法。 （它仍然必须乞求成为当前正在运行的线程）。 由于它仅在当前是静态方法，因此运行`Thread`将进入睡眠状态。 语法为：`Thread.sleep()`
 
-**`yield()`**：`yield`方法与 Thread 的优先级相关。 这也是一个静态方法，因此它仅适用于当前正在运行的线程。 调度程序确保如果线程进入可运行状态，并且其优先级高于池中的任何线程，并且具有比当前正在运行的线程更高的优先级，则优先级较低的运行线程通常会被撞回可运行状态 然后将选择优先级最高的线程来运行。 在任何给定时间，当前正在运行的线程通常不会具有低于池中任何线程的优先级。 yield（）应该做的是使当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程轮流使用。
+**`yield()`**：`yield`方法与`Thread`的优先级相关。 这也是一个静态方法，因此它仅适用于当前正在运行的线程。 调度程序确保如果线程进入可运行状态，并且其优先级高于池中的任何线程，并且具有比当前正在运行的线程更高的优先级，则优先级较低的运行线程通常会被撞回可运行状态 然后将选择优先级最高的线程来运行。 在任何给定时间，当前正在运行的线程通常不会具有低于池中任何线程的优先级。 `yield()`应该做的是使当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程轮流使用。
 
-**`Join()`**：Join 是一种非静态方法。 它使一个线程“连接到另一线程的末端”。 如果将线程 B 加入线程 A，则直到线程 A 完成，线程 B 才会启动。
+**`Join()`**：`Join`是一种非静态方法。 它使一个线程“连接到另一线程的末端”。 如果将线程 B 加入线程 A，则直到线程 A 完成，线程 B 才会启动。
 
 **语法**：
 
@@ -168,21 +169,22 @@ t.start();
 t.join();
 ```
 
-接收当前正在运行的线程，并将其加入到 t 引用的线程的末尾
+接收当前正在运行的线程，并将其加入到`t`引用的线程的末尾
 
-线程可以离开运行状态并返回到 Runnable 状态的其他几种方法。 运行方法完成对 wait（）的调用
+线程可以离开运行状态并返回到`Runnable`状态的其他几种方法。 运行方法完成对`wait()`的调用
 
-**同步**：与 Lock 一起使用。 锁有两种类型。
+**同步**：与锁一起使用。 锁有两种类型。
 
 **静态锁定**
+
 **非静态锁定**
 
 > 每个对象只有一个锁。 一旦线程获得了对象的锁，其他线程就无法进入给定对象的同步块/方法。
 
-仅方法/块可以同步，而不是变量或类。
-一个类可以同时具有同步/同步方法。
-即使一个线程获得了给定对象的锁，线程也可以访问同步块。
-如果线程进入睡眠状态，则它将拥有其拥有的所有锁。 一个线程可以同时具有不同对象的 Lock。
++   仅方法/块可以同步，而不是变量或类。
++   一个类可以同时具有同步/同步方法。
++   即使一个线程获得了给定对象的锁，线程也可以访问同步块。
++   如果线程进入睡眠状态，则它将拥有其拥有的所有锁。 一个线程可以同时具有不同对象的锁。
 
 **语法**：
 
@@ -202,7 +204,7 @@ System.out.println("synchronized");
 
 **同步静态方法**：
 
-静态数据只有一个副本，因此每个类只需要一个锁即可同步静态方法，即整个类的锁。 有这样的锁。 Java 中加载的每个类都有一个表示该类的 java.lang.Class 对应实例。 就是那个 java.lang.Class 实例，其锁用于保护类的静态方法。
+静态数据只有一个副本，因此每个类只需要一个锁即可同步静态方法，即整个类的锁。 有这样的锁。 Java 中加载的每个类都有一个表示该类的`java.lang.Class`对应实例。 就是那个`java.lang.Class`实例，其锁用于保护类的静态方法。
 
 **语法**：
 
@@ -214,34 +216,22 @@ return count;
 }
 ```
 
-MyClass.class 事物称为类文字。 它告诉编译器（谁告诉 JVM）：去找我代表代表 MyClass 类的 Class 实例。
+`MyClass.class`事物称为类文字。 它告诉编译器（谁告诉 JVM）：去找我代表代表`MyClass`类的类实例。
 
 > 在同一类中调用非静态同步方法的线程只有在使用同一实例调用它们时才会彼此阻塞。 由于每个实例只有一个锁。 在同一类中调用静态同步方法的线程将始终相互阻塞，因为每个类只有一个锁。
 
 静态同步方法和非静态同步方法不会相互阻塞。 由于他们需要为其他事物锁定（对象&类）
 
-**注意**： join（），sleep（），yield（）这些方法保持锁定。 在等待释放锁定时。
+**注意**：`join()`，`sleep()`，`yield()`这些方法保持锁定。 在等待释放锁定时。
 
 ## 备忘单
 
-*   可以通过*扩展线程类*并覆盖 run（）方法来创建线程。
-*   也可以通过以下方法创建线程：*实现 Runnable 接口*，然后调用带有 Runnable 参数的 Thread 构造器。
-*   start（）方法只能在线程对象*上调用一次*。
-*   一旦在线程对象上调用 start（）方法，它将成为*执行线程。* 在调用 start（）方法之前，它被称为处于新状态，并且不处于活动状态。
+*   可以通过*扩展线程类*并覆盖`run()`方法来创建线程。
+*   也可以通过以下方法创建线程：*实现`Runnable`接口*，然后调用带有`Runnable`参数的`Thread`构造器。
+*   `start()`方法只能在线程对象*上调用一次*。
+*   一旦在线程对象上调用`start()`方法，它将成为*执行线程。* 在调用`start()`方法之前，它被称为处于新状态，并且不处于活动状态。
 *   不能保证启动后线程执行的顺序。
-*   我们可以通过设置 Thread（Thread）priority（1-10）来影响 Thread 执行的顺序。
-*   正在运行的线程可以通过 wait（），sleep 或 join（）调用进入阻塞/等待状态。
+*   我们可以通过设置`Thread`优先级（1-10）来影响`Thread`执行的顺序。
+*   正在运行的线程可以通过`wait()`，`sleep`或`join()`调用进入阻塞/等待状态。
 *   正在运行的线程可能无法获取同步代码块的锁，因此可能会进入阻止/等待状态。
 *   死线程无法再次启动。
-
-
-
-*   可以通过*扩展线程类*并覆盖 run（）方法来创建线程。
-*   也可以通过以下方法创建线程：*实现 Runnable 接口*，然后调用带有 Runnable 参数的 Thread 构造器。
-*   start（）方法只能在线程对象*上调用一次*。
-*   一旦在线程对象上调用 start（）方法，它将成为*执行线程。* 在调用 start（）方法之前，它被称为处于新状态，并且不处于活动状态。
-*   不能保证启动后线程执行的顺序。
-*   我们可以通过设置 Thread（Thread）priority（1-10）来影响 Thread 执行的顺序。
-*   正在运行的线程可以通过 wait（），sleep 或 join（）调用进入阻塞/等待状态。
-*   正在运行的线程可能无法获取同步代码块的锁，因此可能会进入阻止/等待状态。
-*   死线程无法再次启动。
\ No newline at end of file

docs/64.md

@@ -2,11 +2,11 @@
 
 > 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-lambda-beginners-guide/](https://javabeginnerstutorial.com/core-java-tutorial/java-lambda-beginners-guide/)
 
-本文介绍了 Java 8 中的 Java Lambda 表达式。您可以在此处找到完整的代码[。](https://github.com/JBTAdmin/java-tutorial/tree/master/lambda/src)
+本文介绍了 Java 8 中的 Java Lambda 表达式。[您可以在此处找到完整的代码](https://github.com/JBTAdmin/java-tutorial/tree/master/lambda/src)。
 
 ## Java Lambda 表达式
 
-Java Lambda Expression 是 Java 的一个重要的新功能，已在 Java 8 中引入。Lambda Expression 是不属于任何类的匿名函数（无名称的函数），表示该函数没有名称，并且 没有课程。 Lambda Expression 通过促进 Java 中的函数式编程大大简化了开发。 它用于提供函数式接口的实现（函数式接口是仅包含一种方法的接口。例如，Java 标准的 Runnable 接口是函数式接口）。 它还有助于迭代，过滤和从集合库中提取数据。 Lambda 表达式使您可以将代码视为数据，将功能视为方法参数。
+Java Lambda 表达式是 Java 的一个重要的新功能，已在 Java 8 中引入。Lambda 表达式是不属于任何类的匿名函数（无名称的函数），表示该函数没有名称，并且 没有课程。 Lambda 表达式通过促进 Java 中的函数式编程大大简化了开发。 它用于提供函数式接口的实现（函数式接口是仅包含一种方法的接口。例如，Java 标准的`Runnable`接口是函数式接口）。 它还有助于迭代，过滤和从集合库中提取数据。 Lambda 表达式使您可以将代码视为数据，将功能视为方法参数。
 
 ### Lambda 表达式的语法