内容简介：线程化是指同时执行编程过程以提高应用程序性能的实践。虽然直接在业务应用程序中使用线程并不常见，但它们一直在Java框架中使用。例如，处理大量信息的框架（如
线程化是指同时执行编程过程以提高应用程序性能的实践。虽然直接在业务应用程序中使用线程并不常见，但它们一直在 Java 框架中使用。
例如，处理大量信息的框架（如 Spring Batch ）使用线程来管理数据。同时操作线程或CPU进程可提高性能，从而实现更快，更高效的程序。
找到你的第一个线程：Java的main（）方法
即使你从未直接使用Java线程，你也间接使用它们，因为Java的 main（）方法 包含一个 主线程 。无论何时执行该main()方法，您都执行了main Thread。
学习Thread该类对于理解线程在Java程序中的工作方式非常有帮助。我们可以通过调用currentThread().getName()方法来访问正在执行的线程，如下所示：
<b>public</b> <b>class</b> MainThread {
<b>public</b> <b>static</b> <b>void</b> main(String... mainThread) {
System.out.println(Thread.currentThread().getName());
}
}
此代码将打印“main”，标识当前正在执行的线程。知道如何识别正在执行的线程是吸收线程概念的第一步。
Java线程生命周期
使用线程时，了解线程状态至关重要。Java线程生命周期包含六种线程状态：
- New：Thread()已经实例化了一个新的。
- Runnable接口：本Thread的start()方法被调用。
- Running：start()已调用该方法并且线程正在运行。
- Suspended：线程暂时挂起，可以由另一个线程恢复。
- Blocked：线程正在等待机会运行。当一个线程已经调用该synchronized()方法并且下一个线程必须等到它完成时，就会发生这种情况。
- Terminated：线程的执行完成。
图1. Java线程生命周期的六种状态
还有更多关于线程状态的探索和理解，但图1中的信息足以让您解决这个Java挑战。
并发处理：扩展Thread类
最简单的是，通过扩展Thread类来完成并发处理，如下所示。
<b>public</b> <b>class</b> InheritingThread <b>extends</b> Thread {
InheritingThread(String threadName) {
<b>super</b>(threadName);
}
<b>public</b> <b>static</b> <b>void</b> main(String... inheriting) {
System.out.println(Thread.currentThread().getName() + <font>" is running"</font><font>);
<b>new</b> InheritingThread(</font><font>"inheritingThread"</font><font>).start();
}
@Override
<b>public</b> <b>void</b> run() {
System.out.println(Thread.currentThread().getName() + </font><font>" is running"</font><font>);
}
}
</font>
在这里，我们运行两个线程：MainThread和InheritingThread。当我们start()使用new 调用方法时inheritingThread()，将run()执行方法中的逻辑。
我们还在Thread类构造函数中传递第二个线程的名称，因此输出将是：
main is running. inheritingThread is running.
Runnable接口
您可以实现 Runnable 接口，而不是使用继承。Runnable在Thread构造函数内部传递会导致更少的耦合和更大的灵活性。传递之后Runnable，我们可以start()像上一个示例中那样调用方法：
<b>public</b> <b>class</b> RunnableThread implements Runnable {
<b>public</b> <b>static</b> <b>void</b> main(String... runnableThread) {
System.out.println(Thread.currentThread().getName());
<b>new</b> Thread(<b>new</b> RunnableThread()).start();
}
@Override
<b>public</b> <b>void</b> run() {
System.out.println(Thread.currentThread().getName());
}
}
非守护进程vs守护进程线程
在执行方面，有两种类型的线程：
- 执行非守护程序线程会一直到结束。主线程本身就是非守护程序线程的一个很好的例子。main()除非System.exit()强制程序完成，否则代码输入将始终执行到最后。
- 一个守护线程是相反的，是一个不需要一直执行到结束的处理程序。
请记住规则：如果封闭的非守护程序线程在守护程序线程之前结束，则守护程序线程将在结束之前执行。为了更好地理解守护进程和非守护进程线程的关系，请研究此示例：
<b>import</b> java.util.stream.IntStream;
<b>public</b> <b>class</b> NonDaemonAndDaemonThread {
<b>public</b> <b>static</b> <b>void</b> main(String... nonDaemonAndDaemon) throws InterruptedException {
System.out.println(<font>"Starting the execution in the Thread "</font><font> + Thread.currentThread().getName());
Thread daemonThread = <b>new</b> Thread(() -> IntStream.rangeClosed(1, 100000)
.forEach(System.out::println));
daemonThread.setDaemon(<b>true</b>);
daemonThread.start();
Thread.sleep(10);
System.out.println(</font><font>"End of the execution in the Thread "</font><font> +
Thread.currentThread().getName());
}
}
</font>
在这个例子中，我使用了守护程序线程来声明1到100,000的范围，迭代所有这些，然后打印。但请记住，如果非守护进程的主线程首先完成，守护程序线程将无法完成执行。
输出将按如下方式进行：
- 在主线程中开始执行。
- 打印数字从1到100,000。
- 主线程中的执行结束，很可能在迭代到100,000之前完成。
最终输出将取决于您的JVM实现。
这让我想到了下一点：线程是不可预测的。
线程优先级和JVM
可以使用该setPriority方法确定线程执行的优先级，但是如何处理它取决于JVM实现。Linux，MacOS和Windows都有不同的JVM实现，每个都将根据自己的默认值处理线程优先级。
但是，您设置的线程优先级确实会影响线程调用的顺序。在Thread类上宣布的三个常数是：
<font><i>/**
* The minimum priority that a thread can have.
*/</i></font><font>
<b>public</b> <b>static</b> <b>final</b> <b>int</b> MIN_PRIORITY = 1;
</font><font><i>/**
* The default priority that is assigned to a thread.
*/</i></font><font>
<b>public</b> <b>static</b> <b>final</b> <b>int</b> NORM_PRIORITY = 5;
</font><font><i>/**
* The maximum priority that a thread can have.
*/</i></font><font>
<b>public</b> <b>static</b> <b>final</b> <b>int</b> MAX_PRIORITY = 10;
</font>
尝试对以下代码运行一些测试，以查看最终的执行优先级：
<b>public</b> <b>class</b> ThreadPriority {
<b>public</b> <b>static</b> <b>void</b> main(String... threadPriority) {
Thread moeThread = <b>new</b> Thread(() -> System.out.println(<font>"Moe"</font><font>));
Thread barneyThread = <b>new</b> Thread(() -> System.out.println(</font><font>"Barney"</font><font>));
Thread homerThread = <b>new</b> Thread(() -> System.out.println(</font><font>"Homer"</font><font>));
moeThread.setPriority(Thread.MAX_PRIORITY);
barneyThread.setPriority(Thread.NORM_PRIORITY);
homerThread.setPriority(Thread.MIN_PRIORITY);
homerThread.start();
barneyThread.start();
moeThread.start();
}
}
</font>
即使我们设置moeThread为MAX_PRIORITY，我们也不能指望首先执行此线程。相反，执行顺序将是随机的。
Java线程挑战！
你已经了解了一些关于线程的知识，但这对于这篇文章的Java挑战来说已经足够了。
首先，研究以下代码：
<b>public</b> <b>class</b> ThreadChallenge {
<b>private</b> <b>static</b> <b>int</b> wolverineAdrenaline = 10;
<b>public</b> <b>static</b> <b>void</b> main(String... doYourBest) {
<b>new</b> Motorcycle(<font>"Harley Davidson"</font><font>).start();
Motorcycle fastBike = <b>new</b> Motorcycle(</font><font>"Dodge Tomahawk"</font><font>);
fastBike.setPriority(Thread.MAX_PRIORITY);
fastBike.setDaemon(false);
fastBike.start();
Motorcycle yamaha = <b>new</b> Motorcycle(</font><font>"Yamaha YZF"</font><font>);
yamaha.setPriority(Thread.MIN_PRIORITY);
yamaha.start();
}
<b>static</b> <b>class</b> Motorcycle <b>extends</b> Thread {
Motorcycle(String bikeName) { <b>super</b>(bikeName); }
@Override <b>public</b> <b>void</b> run() {
wolverineAdrenaline++;
<b>if</b> (wolverineAdrenaline == 13) {
System.out.println(<b>this</b>.getName());
}
}
}
}
</font>
这段代码的输出是什么？分析代码并根据您学到的内容尝试确定自己的答案。
A. Harley Davidson
B. Dodge Tomahawk
C. Yamaha YZF
D. Indeterminate
在上面的代码中，我们创建了三个线程。第一个线程是Harley Davidson，我们为此线程分配了默认优先级。Dodge Tomahawk分配了第二个线程MAX_PRIORITY。第三是Yamaha YZF，与MIN_PRIORITY。然后我们开始了线程。
为了确定线程将运行的顺序，您可能首先注意到Motorcycle类扩展了Thread类，并且我们已经在构造函数中传递了线程名称。我们还run()用条件覆盖了方法：if wolverineAdrenaline is equals to 13。
即使它Yamaha YZF是我们执行顺序中的第三个线程，并且MIN_PRIORITY不能保证它将在所有JVM实现的最后执行。
您可能还会注意到，在此示例中，我们将Dodge Tomahawk线程设置为daemon。因为它是一个守护程序线程，Dodge Tomahawk可能永远不会完成执行。但是其他两个线程默认是非守护进程，因此Harley Davidson和Yamaha YZF线程肯定会完成它们的执行。
总之，结果将是D：Indeterminate，因为无法保证线程调度程序将遵循我们的执行顺序或线程优先级。
请记住，我们不能依赖程序逻辑（线程或线程优先级的顺序）来预测JVM的执行顺序。
Java线程常见错误
- 调用该run()方法以尝试启动新线程。
- 试图启动一个线程两次（这将导致一个IllegalThreadStateException）。
- 允许多个进程在不应更改时更改对象的状态。
- 编写依赖于线程优先级的程序逻辑（您无法预测它）。
- 依赖于线程执行的顺序 - 即使我们首先启动一个线程，也不能保证它将首先被执行。
关于Java线程要记住什么
- 调用start()方法启动一个 Thread。
- 可以Thread直接扩展类以使用线程。
- 可以在Runnable接口内实现线程动作。
- 线程优先级取决于JVM实现。
- 线程行为将始终取决于JVM实现。
- 如果封闭的非守护程序线程首先结束，则守护程序线程将无法完成。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持 码农网
猜你喜欢:
本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。
