从Java底层分析多线程行为

例如，处理大量信息的框架（如Spring批处理）使用线程来管理数据。同时操作线程或CPU进程可以提高性能，从而得到更快、更高效的程序。

我们可以通过调用currentThread().getName()方法来访问正在执行的线程，如下所示：

<code>public class MainThread {    public static void main(String[]args) {       System.out.println(Thread.currentThread().getName());    }}/<code>

此代码将打印“main”，标识当前正在执行的线程。这是学习多线程概念的第一步。

Java的线程生命周期包含六种线程状态：

- New：Thread()已经实例化了一个新的。

- Runnable接：本Thread的start()方法被调用。

- Running：start()已调用该方法并且线程正在运行。

- Suspended：线程暂时挂起，可以由另一个线程恢复。

- Blocked：线程正在等待机会运行。当一个线程已经调用该synchronized()方法并且下一个线程必须等到它完成时，就会发生这种情况。

- Terminated：线程的执行完成。

并发多线程处理：扩展Thread类

最简单的是，通过扩展Thread类来完成并发处理，如下所示。

<code>public class InheritingThread extends Thread {    InheritingThread(StringthreadName) {        super(threadName);    }    public static voidmain(String... inheriting) {       System.out.println(Thread.currentThread().getName() + " isrunning");        newInheritingThread("inheritingThread").start();    }    @Override    public void run() {        System.out.println(Thread.currentThread().getName()+ " is running");    }}/<code>

当我们start()使用new 调用方法时inheritingThread()，将run()执行方法中的逻辑。

我们还在Thread类构造函数中传递第二个线程的名称，因此输出将是：

<code>main is running.inheritingThread is running./<code>

并发多线程处理：Runnable接口

Runnable在Thread构造函数内部传递会导致更少的耦合和更大的灵活性。传递之后Runnable，我们可以start()像上一个示例中那样调用方法：

<code>public class RunnableThread implements Runnable {    public static voidmain(String... runnableThread) {       System.out.println(Thread.currentThread().getName());        new Thread(new RunnableThread()).start();    }    @Override    public void run() {       System.out.println(Thread.currentThread().getName());    }/<code>

非守护进程vs守护进程线程

在执行方面，有两种类型的线程：

- 执行非守护程序线程会一直到结束。主线程本身就是非守护程序线程的一个很好的例子。main()除非System.exit()强制程序完成，否则代码输入将始终执行到最后。

- 一个守护线程是相反的，是一个不需要一直执行到结束的处理程序。

请记住规则：如果封闭的非守护程序线程在守护程序线程之前结束，则守护程序线程将在结束之前执行。为了更好地理解守护进程和非守护进程线程的关系，请参考以下示例

<code>import java.util.stream.IntStream;public class NonDaemonAndDaemonThread {    public static voidmain(String... nonDaemonAndDaemon) throws                        InterruptedException {       System.out.println("Starting the execution in the Thread "+      Thread.currentThread().getName());        Thread daemonThread = newThread(() ->     IntStream.rangeClosed(1, 100000)               .forEach(System.out::println));       daemonThread.setDaemon(true);        daemonThread.start();        Thread.sleep(10);        System.out.println("Endof the execution in the Thread " +                                             Thread.currentThread().getName());    }}/<code>

在这个例子中，我使用了守护程序线程来声明1到100,000的范围，迭代所有这些，然后打印。

线程优先级和JVM

可以使用该setPriority方法确定线程执行的优先级，但是如何处理它取决于JVM实现。Linux，MacOS和Windows都有不同的JVM实现，每个都将根据自己的默认值处理线程优先级。

但是，你设置的线程优先级确实会影响线程调用的顺序。在Thread类上的三个常数是：

<code> /**    * The minimum priority that athread can have.     */    public static final intMIN_PRIORITY = 1;   /**     * The default priority that isassigned to a thread.     */    public static final intNORM_PRIORITY = 5;    /**     * The maximum priority that athread can have.     */publicstaticfinalintMAX_PRIORITY=10;/<code>

尝试对以下代码运行一些测试，以查看最

<code>public class ThreadPriority {    public static voidmain(String... threadPriority) {        Thread moeThread = newThread(() -> System.out.println("Moe"));        Thread barneyThread = newThread(() -> System.out.println("Barney"));        Thread homerThread = newThread(() -> System.out.println("Homer"));       moeThread.setPriority(Thread.MAX_PRIORITY);       barneyThread.setPriority(Thread.NORM_PRIORITY);       homerThread.setPriority(Thread.MIN_PRIORITY);        homerThread.start();        barneyThread.start();        moeThread.start();    }}/<code>

即使我们设置moeThread为MAX_PRIORITY，我们也不能指望首先执行此线程。相反，执行顺序将是随机的。

但是，使用常量有一个问题：如果传递的优先级数字不在1到10的范围内，setPriority（）方法将引发IllegalArgumentException。所以我们可以使用枚举来解决这个问题。使用枚举Enums既简化了代码，又能够更好地控制代码的执行。

<code>public class ThreadChallenge {    private static int line = 10;    public static voidmain(String... doYourBest) {        newtool("Car").start();        tool Bike = newtool("Bike");       Bike.setPriority(Thread.MAX_PRIORITY);        Bike.setDaemon(false);        Bike.start();        tool Train = newtool("Train");       Train.setPriority(Thread.MIN_PRIORITY);        Train.start();    }    static class tool extends Thread{        tool(String Name) {super(Name); }        @Override public void run(){            line++;            if (line == 13) {               System.out.println(this.getName());            }        }    }}/<code>

在上面的代码中，我们创建了三个线程：

第一个线程是Car，我们为此线程分配了默认优先级。

第二个线程是Bike，分配了分配了MAX_PRIORITY优先级。

第三个线程是Train，分配了MIN_PRIORITY优先级。

然后我们开始了多线程。为了确定线程将运行的顺序，你可能首先注意到tool类扩展了Thread类，并且我们已经在构造函数中传递了线程名称。

我们还run()中如果line等于13就进行打印。

注意！即使Train是我们执行顺序中的第三个线程，并且MIN_PRIORITY不能保证它将在所有JVM实现的最后执行。

你可能还会注意到，在此示例中，我们将Bike线程设置为守护，所以它是一个守护程序线程，Bike可能永远不会完成执行。但是其他两个线程默认是非守护进程，因此Car和Train线程肯定会完成它们的执行。

总之，结果将是D：不确定，因为无法保证线程调度程序将遵循我们的执行顺序或线程优先级。请记住，如果不借助JUC的工具，我们不能依赖程序逻辑（线程或线程优先级的顺序）来预测线程的执行顺序。

多线程常见错误

- 调用run()方法以尝试启动新线程。

- 试图启动一个线程两次（这将导致一个IllegalThreadStateException）。

- 允许多个进程在不应更改时更改对象的状态。

- 编写依赖于线程优先级的程序逻辑

- 依赖于线程执行的顺序 - 即使我们首先启动一个线程，也不能保证它将首先被执行。

关于多线程要记住什么

- 调用start()方法启动一个 Thread。

- 可以Thread直接扩展类以使用线程。

- 可以在Runnable接口内实现线程动作。

- 线程优先级取决于JVM实现。

- 线程行为将始终取决于JVM实现。

- 如果封闭的非守护程序线程首先结束，则守护程序线程将无法完成。

小编是一个有着5年工作经验的程序员，关于Java，自己有做材料的整合，一个完整学习Java的路线，学习材料和工具。需要的伙伴可以私信我，发送“交流”后就可免费获取。对于学习Java有任何问题（学习方法，学习效率，如何就业）都可以问我。希望你也能凭自己的努力，成为下一个优秀的程序员！

閱讀更多 程序員小皮 的文章

關鍵字: 多线程 批处理 线程