● Java线程视频教程
● 创建和启动线程
● Thread子类
● Runnable接口的实现
○ Java类实现Runnable
○ Runnable的匿名实现
○ Java Lambda的方式实现Runnable
○ 使用Runnable启动线程
● 使用子类还是Runnable？
● 常见陷阱：调用run()代替start()
● 线程名
● Thread.currentThread（）
● Java线程示例
● 暂停线程
● 停止线程
Java线程就像一个虚拟CPU，可以在Java应用程序内部执行Java代码。 启动Java应用程序时，其main（）方法由主线程执行-主线程是由Java VM创建的用于运行您的应用程序的特殊线程。 在应用程序内部，您可以创建和启动更多线程，这些线程可以与主线程并行执行应用程序代码的某些部分。
Java线程是与任何其他Java对象一样的对象。 线程是java.lang.Thread类的实例，或者此类的子类实例。 除了成为对象之外，java线程还可以执行代码。 在本Java线程教程中，我将解释如何创建和启动线程。
Java线程视频教程
如果您喜欢视频，请参阅以下Java Threads教程的视频版本。
创建和启动线程
用Java创建线程是这样完成的：
Thread thread = new Thread();
要启动Java线程，您将调用其start()方法，如下所示：
thread.start();
这个例子没有为线程指定任何代码来执行。 因此，线程在启动后将立即再次停止。
有两种方法可以指定线程应执行的代码。 第一种是创建Thread的子类并覆盖run()方法。 第二种方法是将实现Runnable的对象（java.lang.Runnable）传递给Thread构造函数。下面介绍这两种方法。
Thread子类
指定线程要运行什么代码的第一种方法是创建Thread的子类并覆盖run()方法。 调用start()后，线程将执行run()方法。 这是创建Java Thread子类的示例：
public class MyThread extends Thread {
public void run(){
System.out.println("MyThread running");
}
}
要创建并启动上述线程，您可以执行以下操作：
MyThread myThread = new MyThread();
myTread.start();
一旦线程启动，start()调用将返回。 它不会等到run()方法完成。 run()方法将像由另一个CPU执行一样执行。 当run()方法执行时，它将打印出文本“ MyThread running”。
您还可以像这样创建Thread的匿名子类：
Thread thread = new Thread(){
public void run(){
System.out.println("Thread Running");
}
}
thread.start();
一旦新线程执行了run()方法，本示例将打印出文本“ Thread running”。
Runnable接口的实现
指定线程应运行什么代码的第二种方法是创建一个实现java.lang.Runnable接口的类。 可以通过Java线程执行实现Runnable接口的Java对象。 本教程的稍后部分将介绍如何完成此操作。
Runnable接口是Java平台随附的标准Java接口。 Runnable接口只有一个方法run（）。 基本上，这是Runnable界面的外观：
public interface Runnable() {
public void run();
}
run（）方法的实现中必须包括该线程在执行时应该执行的操作。 有三种方法可以实现Runnable接口：
1.创建一个实现Runnable接口的Java类。
2.创建一个实现Runnable接口的匿名类。
3.创建一个实现Runnable接口的Java Lambda。
以下各节将说明所有这三个选项。
Java类实现Runnable
实现Java Runnable接口的第一种方法是创建自己的实现Runnable接口的Java类。 这是实现Runnable接口的自定义Java类的示例：
public class MyRunnable implements Runnable {
public void run(){
System.out.println("MyRunnable running");
}
}
Runnable实现的所有作用是打印出MyRunnable运行文本。 打印完该文本后，run（）方法退出，并且运行run（）方法的线程将停止。
Runnable的匿名实现
您还可以创建Runnable的匿名实现。 这是实现Runnable接口的匿名Java类的示例：
Runnable myRunnable =
new Runnable(){
public void run(){
System.out.println("Runnable running");
}
}
除了是一个匿名类之外，该示例与使用自定义类实现Runnable接口的示例非常相似。
Java Lambda的方式实现Runnable
实现Runnable接口的第三种方法是通过创建Runnable接口的Java Lambda实现。 这是可能的，因为Runnable接口只有一个未实现的方法，因此实际上（尽管可能是无意地）是一个功能性Java接口。
这是实现Runnable接口的Java lambda表达式的示例：
Runnable runnable =
() -> { System.out.println("Lambda Runnable running"); };
使用Runnable启动线程
要使run（）方法由线程执行，请将实现Runnable接口的类，匿名类或lambda表达式的实例传递给其构造函数中的Thread。 这是完成的方式：
Runnable runnable = new MyRunnable(); // or an anonymous class, or lambda...
Thread thread = new Thread(runnable);
thread.start();
当线程启动时，它将调用MyRunnable实例的run（）方法，而不是执行它自己的run（）方法。 上面的示例将打印出文本“ MyRunnable running”。
使用子类还是Runnable？
对于这两种方法中哪一种最好没有任何规则。 两种方法都有效。 不过，就我个人而言，我更喜欢实现Runnable，并将实现的实例传递给Thread实例。 当线程池执行Runnable时，很容易将Runnable实例排队，直到池中的线程空闲为止。 使用Thread子类很难做到这一点。
有时您可能必须实现Runnable以及Thread的子类。 例如，如果创建一个可以执行多个Runnable的Thread子类。 实现线程池时通常是这种情况。
常见陷阱：调用run()代替start()
创建和启动线程时，常见的错误是调用Thread的run（）方法而不是start（），如下所示：
Thread newThread = new Thread(MyRunnable());
newThread.run(); //should be start();
最初，您可能不会注意到任何事情，因为Runnable的run（）方法是按预期执行的。 但是，它不会由您刚刚创建的新线程执行。 相反，run（）方法由创建线程的线程执行。 换句话说，该线程执行了以上两行代码。 要使新创建的线程newThread调用MyRunnable实例的run（）方法，必须调用newThread.start（）方法。
线程名
创建Java线程时，可以为其命名。 该名称可以帮助您区分不同的线程。 例如，如果有多个线程写入System.out，则可以方便地查看哪个线程写入了文本。 这是一个例子：
Thread thread = new Thread("New Thread") {
public void run(){
System.out.println("run by: " + getName());
}
};
thread.start();
System.out.println(thread.getName());
请注意，作为参数传递给线程构造函数的字符串“ New Thread”。 此字符串是线程的名称。 可以通过Thread的getName（）方法获得名称。 使用Runnable实现时，您还可以将名称传递给Thread。 看起来是这样的：
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable, "New Thread");
thread.start();
System.out.println(thread.getName());
但是请注意，由于MyRunnable类不是Thread的子类，因此它无权访问执行它的线程的getName（）方法。
Thread.currentThread（）
Thread.currentThread（）方法返回对执行currentThread（）的Thread实例的引用。 这样，您就可以访问代表执行给定代码块的线程的Java Thread对象。 这是如何使用Thread.currentThread（）的示例：
Thread thread = Thread.currentThread();
一旦拥有对Thread对象的引用，就可以在其上调用方法。 例如，您可以获取当前正在执行代码的线程的名称，如下所示：
String threadName = Thread.currentThread().getName();
Java线程示例
这是一个小例子。首先，它打印出执行main（）方法的线程的名称。该线程由JVM分配。然后，它启动10个线程，并给它们一个全名（“” + i）。然后，每个线程将其名称打印出来，然后停止执行。
public class ThreadExample {
public static void main(String[] args){
System.out.println(Thread.currentThread().getName());
for(int i=0; i<10; i++){
new Thread("" + i){
public void run(){
System.out.println("Thread: " + getName() + " running");
}
}.start();
}
}
}
请注意，即使线程按顺序启动（1、2、3等），它们也可能不会顺序执行，这意味着线程1可能不是第一个将其名称写入System.out的线程。这是因为线程原则上是并行执行的，而不是顺序执行的。 JVM和/或操作系统确定线程的执行顺序。此顺序不必与开始时的顺序相同。
暂停线程
线程可以通过调用静态方法Thread.sleep（）来暂停自身。 sleep（）以毫秒为参数。 sleep（）方法将在重新开始执行之前尝试休眠该毫秒数。 线程sleep（）并不是100％精确的，但是还是很不错的。 这是通过调用Thread sleep（）方法将Java线程暂停3秒（3.000毫秒）的示例：
try {
Thread.sleep(10L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
执行上述Java代码的线程将休眠大约10秒钟（10,000毫秒）。
停止线程
停止Java线程需要对线程实现代码进行一些准备。 Java Thread类包含stop（）方法，但已弃用。原始的stop（）方法无法保证线程处于什么状态。这意味着，线程在执行期间可以访问的所有Java对象将处于未知状态。如果您的应用程序中的其他线程也可以访问相同的对象，则您的应用程序可能会意外失败并且无法预期。
不必调用stop（）方法，您必须实现线程代码，以便可以将其停止。这是实现Runnable的类的示例，该类包含一个名为doStop（）的额外方法，该方法向Runnable发出停止信号。 Runnable将检查此信号，并在准备就绪时将其停止。
public class MyRunnable implements Runnable {
private boolean doStop = false;
public synchronized void doStop() {
this.doStop = true;
}
private synchronized boolean keepRunning() {
return this.doStop == false;
}
@Override
public void run() {
while(keepRunning()) {
// keep doing what this thread should do.
System.out.println("Running");
try {
Thread.sleep(3L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
注意doStop（）和keepRunning（）方法。打算从执行MyRunnable的run（）方法的线程之外的另一个线程调用doStop（）。由执行MyRunnable的run（）方法的线程在内部调用keepRunning（）方法。只要未调用doStop（），keepRunning（）方法将返回true-意味着执行run（）方法的线程将继续运行。
这是一个启动Java线程的示例，该线程执行上述MyRunnable类的实例，并在延迟后再次停止它：
public class MyRunnableMain {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
try {
Thread.sleep(10L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
myRunnable.doStop();
}
}
本示例首先创建一个MyRunnable实例，然后将该实例传递给线程并启动该线程。然后执行main（）方法的线程（主线程）休眠10秒钟，然后调用MyRunnable实例的doStop（）方法。这将导致执行MyRunnable方法的线程停止，因为在调用doStop（）之后，keepRunning（）将返回false。
请记住，如果您的Runnable实现不仅需要run（）方法（例如，也需要stop（）或pause（）方法），那么您将无法再使用Java Lambda表达式创建您的Runnable实现。 Java lambda只能实现一个方法。相反，您必须使用自定义类或扩展Runnable的自定义接口，该接口具有额外的方法，并由匿名类实现。
译自：Creating and Starting Java Threads
Jakob Jenkov
Last update: 2021-03-09
