# Java 线程教程

> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-thread-tutorial/](https://javabeginnerstutorial.com/core-java-tutorial/java-thread-tutorial/)

可以以两种方式使用线程术语

*   类`java.lang.Thread`的实例
*   执行线程

线程的*实例*是一个对象，与 Java 中的其他任何对象一样，它包含在堆上生存和死亡的变量和方法。 但是*执行线程*是一个单独的进程，具有其*栈*调用。 即使您没有在程序中创建任何线程，一个线程也将在其中运行，然后`main()`方法将启动该线程。

**注意**：如果是线程，大多数事情都是不可预测的。

## 线程类型

线程可以是两种类型。

*   用户线程
*   守护程序线程

这两类线程之间的区别在于，JVM 仅在所有用户线程完成时才退出应用。 JVM 并不关心守护线程的状态。

## 线程定义

可以通过两种方式定义线程

*   扩展`java.lang.Thread`类。
*   实现`Runnable`接口。

### 扩展 Java 线程类：

该类需要**扩展**，**线程**类并覆盖`run()`方法。

```java
class MyThread extends Thread
{
public void run()
{
System.out.println("Important job running in MyThread");
}
}
```

但是这种方法的问题是类不能再扩展任何类。

> 线程的`run()`方法可以在类中重载。 但是，JVM 仅考虑`run()`方法（不带参数）。 任何其他覆盖的方法都需要显式调用。

### 实现`Runnable`接口

该类需要实现`Runnable`接口，并且覆盖`run()`方法。以这种方式创建线程使您可以灵活地扩展所需的任何类。

```java
class MyRunnable implements Runnable {

public void run() {

System.out.println("Important job running in MyRunnable");

} }
```

### 实例化线程：

每个执行线程都以`Thread`类的实例开始。 无论如何，都需要在创建执行线程之前创建线程对象。
两种情况下创建线程对象均不同。 如果扩展了`Thread`类，则可以使用`new`关键字直接启动类，因为它已经扩展了`Thread`类本身。

```java
MyThread t = new MyThread()
```

如果实现`Runnable`接口。 首先创建的可运行类需要实例化。

```java
MyRunnable r = new MyRunnable();
```

现在将此可运行对象传递给`Thread`。

```java
Thread t = new Thread(r);
```

如果使用无参构造器创建线程，则该线程将调用其自己的`run()`。 这是在第一种情况下发生的（扩展`Thread`类），但是在`Runnable`的情况下，需要知道实现了`Runnable`接口的类的`run`方法需要被调用，而不是`Thread`类的`run()`。 因此，我们需要将该类作为参数传递给`Thread`。 单个可运行实例可以传递给多个`Thread`对象。

```java
public class TestThreads {

public static void main (String [] args) {

MyRunnable r = new MyRunnable();

Thread foo = new Thread(r);

Thread bar = new Thread(r);

Thread bat = new Thread(r);
}}
```

将相同的目标分配给多个线程意味着多个执行线程将运行同一作业（并且同一作业将执行多次）。

> `Thread`类本身实现了`Runnable`。 （毕竟，它有一个我们要覆盖的`run()`方法。）这意味着您可以将`Thread`传递给另一个`Thread`的构造器。

## `Thread`类中的重载构造器：

```java
Thread()
Thread(Runnable target)
Thread(Runnable target, String name)
Thread(String name)
```

到目前为止，我们已经创建了一个`Thread`对象，并且它知道以`run()`方法的形式做什么。 但是到目前为止，它仍然是一个对象。 它没有调用栈。 换句话说，执行线程尚未启动。 仅当在线程上调用`start()`方法时，线程对象才会具有其栈。

到目前为止，线程具有两种状态。

*   新状态（已创建线程对象，但未调用`Start`方法）
*   可运行（活动）状态（调用启动方法）

> 直接从 Java 代码调用`run()`方法意味着您正在调用方法，并且不会创建栈。

当线程处于可运行状态时，表示已创建线程，但尚未执行该线程的`run`方法，并且该线程正在等待轮到他。 选定线程后，线程的`run`方法将执行，该状态称为运行状态。

**线程调度程序**：

线程调度程序是 JVM 的一部分，它决定在任何给定的时间应该运行哪个线程，并使线程退出运行状态 。 调度程序可以选择任何处于可运行状态的线程作为唯一正在运行的线程。 如果线程不处于可运行状态，则不能将其选择为当前正在运行的线程。 某种可能在某种程度上影响调度程序的方法（**注**：我们无法控制线程调度程序的行为）

**这些方法来自线程类**

```java
* public static void sleep(long millis) throws InterruptedException
* public static void yield()
* public final void join() throws InterruptedException
* public final void setPriority(int newPriority)
```

**`Object`类中的方法。**

```java
* public final void wait() throws InterruptedException
* public final void notify()
* public final void notifyAll()
```

到目前为止，我们遇到了线程的三种状态

*   新增
*   可运行的
*   正在运行

线程还有更多状态，线程将无法运行。

*   等待/阻止/睡眠
*   已死

当线程的`run`方法完成执行时，该线程处于死亡状态。

`sleep()`：`sleep()`方法是`Thread`类的静态方法。 （它仍然必须乞求成为当前正在运行的线程）。 由于它仅在当前是静态方法，因此运行`Thread`将进入睡眠状态。 语法为：`Thread.sleep()`

**`yield()`**：`yield`方法与`Thread`的优先级相关。 这也是一个静态方法，因此它仅适用于当前正在运行的线程。 调度程序确保如果线程进入可运行状态，并且其优先级高于池中的任何线程，并且具有比当前正在运行的线程更高的优先级，则优先级较低的运行线程通常会被撞回可运行状态，然后将选择优先级最高的线程来运行。 在任何给定时间，当前正在运行的线程通常不会具有低于池中任何线程的优先级。 `yield()`应该做的是使当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程轮流使用。

**`Join()`**：`Join`是一种非静态方法。 它使一个线程“连接到另一线程的末端”。 如果将线程 B 连接线程 A，则直到线程 A 完成，线程 B 才会启动。

**语法**：

```java
Thread t = new Thread();
t.start();
t.join();
```

接收当前正在运行的线程，并将其连接到`t`引用的线程的末尾

线程可以离开运行状态并返回到`Runnable`状态的其他几种方法。 运行方法完成对`wait()`的调用

**同步**：与锁一起使用。 锁有两种类型。

**静态锁定**

**非静态锁定**

> 每个对象只有一个锁。 一旦线程获得了对象的锁，其他线程就无法进入给定对象的同步块/方法。

+   仅方法/块可以同步，而不是变量或类。
+   一个类可以同时具有同步/同步方法。
+   即使一个线程获得了给定对象的锁，线程也可以访问同步块。
+   如果线程进入睡眠状态，则它将拥有其拥有的所有锁。 一个线程可以同时具有不同对象的锁。

**语法**：

```java
class SyncTest {

public void doStuff() {

System.out.println("not synchronized");

synchronized(this) {

System.out.println("synchronized");

}}}
```

**同步静态方法**：

静态数据只有一个副本，因此每个类只需要一个锁即可同步静态方法，即整个类的锁。 有这样的锁。 Java 中加载的每个类都有一个表示该类的`java.lang.Class`对应实例。 就是那个`java.lang.Class`实例，其锁用于保护类的静态方法。

**语法**：

```java
public static synchronized int getCount() {

return count;

}
```

`MyClass.class`事物称为类字面值。 它告诉编译器（谁告诉 JVM）：去找我代表代表`MyClass`类的类实例。

> 在同一类中调用非静态同步方法的线程只有在使用同一实例调用它们时才会彼此阻塞。 由于每个实例只有一个锁。 在同一类中调用静态同步方法的线程将始终相互阻塞，因为每个类只有一个锁。

静态同步方法和非静态同步方法不会相互阻塞。 由于他们需要为其他事物锁定（对象&类）

**注意**：`join()`，`sleep()`，`yield()`这些方法保持锁定。 在等待释放锁定时。

## 备忘单

*   可以通过*扩展线程类*并覆盖`run()`方法来创建线程。
*   也可以通过以下方法创建线程：*实现`Runnable`接口*，然后调用带有`Runnable`参数的`Thread`构造器。
*   `start()`方法只能在线程对象*上调用一次*。
*   一旦在线程对象上调用`start()`方法，它将成为*执行线程。* 在调用`start()`方法之前，它被称为处于新状态，并且不处于活动状态。
*   不能保证启动后线程执行的顺序。
*   我们可以通过设置`Thread`优先级（1-10）来影响`Thread`执行的顺序。
*   正在运行的线程可以通过`wait()`，`sleep`或`join()`调用进入阻塞/等待状态。
*   正在运行的线程可能无法获取同步代码块的锁，因此可能会进入阻止/等待状态。
*   死线程无法再次启动。