• 深入理解多线程（第一篇）

    ✅作者简介：大家好我是@每天都要敲代码，一位材料转码农的选手，希望一起努力，一起进步！
    📃个人主页：@每天都要敲代码的个人主页

    🔥系列专栏：JavaSE从入门到精通
    💬推荐一款模拟面试、刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习

    目录

     一：进程与多线程概述

    1.多线程并发的理解 

    2.分析程序存在几个线程

    二：实现线程的两种方式

    1.第一种方式：直接继承Thread，重写run方法

    2.第二种方式：实现Runnable接口，重写run方法

    3.采用匿名内部类的方式

    三：线程生命周期

    四：线程简单实操

    1.获取线程的名字 & 获取当前线程对象

    2.线程的sleep方法

    3.终止线程的睡眠 

    4.终止线程的执行

    5.线程的调度（了解）

     一：进程与多线程概述

    ❤️什么是进程？什么是线程？
          ⭐️进程是一个应用程序（1个进程是一个软件）
          ⭐️线程是一个进程中的执行场景/执行单元
          ⭐️一个进程可以启动多个线程
    ❤️对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。
          ⭐️首先会先启动JVM，而JVM就是一个进程。
          ⭐️JVM再启动一个主线程调用main方法。
          ⭐️同时再启动一个垃圾回收线程负责看护，回收垃圾。
          ⭐️所以，最起码现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。
    ❤️进程和线程是什么关系？

          ⭐️我们来通过身边的示例来说明一下：

               假如阿里巴巴是一个进程，那么

                马云：阿里巴巴的一个线程
                员工：阿里巴巴的一个线程 
          ⭐️进程可以看做是现实生活当中的公司；线程可以看做是公司当中的某个员工

    ❤️注意：
          ⭐️进程A和进程B的内存独立不共享。（例如：阿里巴巴和京东资源不会共享的）
              魔兽游戏是一个进程，酷狗音乐是一个进程；这两个进程是独立的，不共享资源。

          ⭐️在java语言中：线程A和线程B，堆内存和方法区，内存共享；但是栈内存独立，一个线程一个栈。
    ❤️多线程并发：            
          ⭐️假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。    
          ⭐️例如：火车站，可以看做是一个进程；火车站中的每一个售票窗口可以看做是一个线程。我在窗口A购票，朋友可以在窗口A购票，朋友不需要等我，我也不需要等朋友；所以多线程并发可以提高效率。

          ⭐️java中之所以有多线程机制，目的就是为了提高程序的处理效率

    ❤️思考题：
          ⭐️使用了多线程机制之后，main方法结束，是不是有可能程序也不会结束？
            main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。

           ⭐️我们通过画图理解一下：

    1.多线程并发的理解 

    ❤️分析一个问题：对于单核的CPU来说，真的可以做到真正的多线程并发吗？

        ⭐对于多核的CPU电脑来说，真正的多线程并发是没问题的；
            4核CPU表示同一个时间点上，可以真正的有4个进程并发执行。

        ⭐什么是真正的多线程并发？
                t1线程执行t1的，t2线程执行t2的；t1不会影响t2，t2也不会影响t1。这叫做真正的多线程并发。

        ⭐单核的CPU表示只有一个大脑：
           单核的CPU不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉！对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，给人来的感觉是：多个事情同时在做！
           例如：线程A：播放音乐，线程B：运行魔兽游戏；线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行，给我们的感觉是同时并发的。
           再例如：以前的电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像一根钢针扎到手上，到最终感觉到疼，这个过程是需要“很长的”时间的，在这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

    2.分析程序存在几个线程

    1. package com.bjpowernode.java.thread;
    2.  
    3. /*分析以下程序，有几个线程，除垃圾回收线程之外。有几个线程？
    4.         1个线程（因为程序只有1个栈）*/
    5. public class ThreadTest01 {
    6.     public static void main(String[] args) {
    7.         System.out.println("main begin");
    8.         m1();
    9.         System.out.println("main over");
    10.     }
    11.  
    12.     private static void m1() {
    13.         System.out.println("m1 begin");
    14.         m2();
    15.         System.out.println("m1 over");
    16.     }
    17.  
    18.     private static void m2() {
    19.         System.out.println("m2 begin");
    20.         m3();
    21.         System.out.println("m2 over");
    22.     }
    23.  
    24.     private static void m3() {
    25.         System.out.println("m3 execute!");
    26.     }
    27. }

    只有一个主线程（主栈），没有启动分支栈（分支线程）；所以只有一个线程！

    二：实现线程的两种方式

    java支持多线程机制！并且java已经将多线程实现了，我们只需要继承就行了！

    1.第一种方式：直接继承Thread，重写run方法

    ⭐实现线程的第一种方式：

        编写一个类，直接继承java.lang.Thread，重写run()方法

        怎么创建线程对象？ new就行了，例如： MyThread t = new MyThread()。
        怎么启动线程呢？ 调用线程对象的start()方法。
        start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码任务完成之后，瞬间就结束了。调用start方法的这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开出来，start()方法就结束了；线程就启动成功了。启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）。 run方法在分支栈的栈底部，main方法在主栈的栈底部；run和main是平级的。

    ⭐注意：
        亘古不变的道理：方法体当中的代码永远都是自上而下的顺序依次逐行执行的。

    ⭐如果调用的是t.run，下面分支线程的i执行完，才会执行主线程的i；如果调用的是t.start()主线程和分支线程是一块执行的

    ⭐我们通过内存图来了解一下：

    调用run：

    调用start:

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest02 {
    4.     public static void main(String[] args) {
    5.         // 这里是main方法，这里的代码属于主线程，在主栈中运行。
    6.         // 新建一个分支线程对象
    7.         MyThread t = new MyThread();
    8.         // 启动线程，调用start()方法
    9.         t.start(); // 瞬间就结束了
    10.  
    11.         //t.run(); // 不会启动线程，不会分配新的分支栈。（这种方式就是单线程。）
    12.  
    13.         // 这里的代码还是运行在主线程中。
    14.         for(int i = 0; i < 1000; i++){
    15.             System.out.println("主线程--->" + i);
    16.         }
    17.     }
    18. }
    19.  
    20. class MyThread extends Thread {
    21.     // 重写run方法
    22.     public void run() {
    23.         // 编写程序，这段程序运行在分支线程中（分支栈）。
    24.         for(int i = 0; i < 1000; i++){
    25.             System.out.println("分支线程--->" + i);
    26.         }
    27.     }
    28. }

    2.第二种方式：实现Runnable接口，重写run方法

    第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其它的类，更灵活，面向接口编程；如果是第一种直接就继承了Thread类，类只能单继承，就不能在继承其它类了，比较局限！

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest03 {
    4.     public static void main(String[] args) {
    5.         // 创建一个可运行的对象
    6.         MyRunnable r = new MyRunnable();
    7.         // 将可执行的对象封装成一个线程对象
    8.         Thread t = new Thread(r);
    9.         
    10.         // Thread t = new Thread(new MyRunnable());// 合并代码
    11.  
    12.         // 启动线程
    13.         t.start();
    14.  
    15.         for(int i = 0; i < 1000; i++){
    16.             System.out.println("主线程--->" + i);
    17.         }
    18.     }
    19. }
    20.  
    21. class MyRunnable implements Runnable{
    22.     public void run() {
    23.         for(int i = 0; i < 1000; i++){
    24.             System.out.println("分支线程--->" + i);
    25.         }
    26.     }
    27. }

    3.采用匿名内部类的方式

    牵扯到接口，我们也可以不需要在通过实现接口的方式，也可以直接通过匿名内部类的方式去调用！

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest04 {
    4.     public static void main(String[] args) {
    5.         // 创建线程对象，采用匿名内部类方式
    6.         Thread t = new Thread(new Runnable() {
    7.             public void run() {
    8.                 for (int i = 0; i < 100; i++) {
    9.                     System.out.println("分支线程---》"+i);
    10.                 }
    11.             }
    12.         });
    13.  
    14.         // 启动线程
    15.         t.start();
    16.  
    17.         for (int i = 0; i < 100; i++) {
    18.             System.out.println("主线程---》"+i);
    19.         }
    20.     }
    21. }

    三：线程生命周期

    线程的生命周期总共有5个状态：新建状态、就绪状态、运行状态、阻塞状态、死亡状态

    四：线程简单实操

    1.获取线程的名字 & 获取当前线程对象

    1、怎么获取当前线程对象

    1.    static Thread currentThread() // 是一个静态方法
    2.    Thread th = Thread.currentThread(); // 返回值th就是当前线程。

    2、获取线程对象的名字

    String name = 线程对象.getName();

    3、修改线程对象的名字

    线程对象.setName("线程名字");

    4、当线程没有设置名字的时候，默认的名字规律
        Thread-0
        Thread-1
        .....

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest05 {
    4.  
    5.     public void doSome(){
    6.         //如果当前类不是线程类，super和this就不行了
    7.         //this.getName();
    8.         //super.getName();
    9.         // 但是这样可以
    10.         String name = Thread.currentThread().getName();
    11.         System.out.println("------->" + name); // main，在main方法里创建的对象
    12.     }
    13.  
    14.     public static void main(String[] args) {
    15.  
    16.         ThreadTest05 threadTest05 = new ThreadTest05();
    17.         threadTest05.doSome();
    18.  
    19.         // 获取当前线程对象
    20.         // currentThread就是当前线程对象
    21.         // 这个代码出现在main方法当中，所以当前线程就是主线程。
    22.         Thread th = Thread.currentThread();
    23.         System.out.println(th.getName()); // main
    24.  
    25.         // 创建线程对象
    26.         MyThread2 t = new MyThread2();
    27.         // 设置线程的名字
    28.         t.setName("zl-gh");
    29.         // 获取线程的名字
    30.         System.out.println(t.getName()); // zl-gh
    31.  
    32.         // 如果不设置线程的名字默认是Thread-0 1 2 ......
    33.         MyThread2 t2 = new MyThread2();
    34.         System.out.println(t2.getName()); // Thread-1
    35.  
    36.         t2.start();
    37.         // 启动线程
    38.         t.start();
    39.     }
    40. }
    41. class MyThread2 extends Thread{
    42.     public void run() {
    43.         for (int i = 0; i < 100; i++) {
    44.             // currentThread就是当前线程对象。当前线程是谁呢？
    45.             // 那个线程调用start()方法，线程执行run方法，那么这个当前线程就是那个
    46.             Thread th = Thread.currentThread();
    47.             System.out.println(th.getName()+"--->"+i);
    48.  
    49.             // 在这里，super和this也是可以的（当前类是线程类）
    50.             System.out.println(this.getName()+"--->"+i);
    51.             System.out.println(super.getName()+"--->"+i);
    52.         }
    53.     }
    54. }

    2.线程的sleep方法

    static void sleep(long millis)
    1、静态方法：Thread.sleep(1000);
    2、参数是毫秒，需要进行异常处理！
    3、作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用
    4、Thread.sleep()方法，可以做到这种效果：
            间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest06 {
    4.     public static void main(String[] args) {
    5.  
    6.         // 使用案例1：
    7.         try {
    8.             // 休眠5秒
    9.             Thread.sleep(5000);
    10.         } catch (InterruptedException e) {
    11.             e.printStackTrace();
    12.         }
    13.         // 5秒过后才会打印Hello World
    14.         System.out.println("Hello World");
    15.  
    16.         // 使用案例2：
    17.         for (int i = 0; i < 10; i++) {
    18.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    19.             try {
    20.                 // 让当前线程休眠1秒；没隔1秒打印1个数字
    21.                 Thread.sleep(1000);
    22.             } catch (InterruptedException e) {
    23.                 e.printStackTrace();
    24.             }
    25.         }
    26.     }
    27. }

    关于Thread.sleep()方法的一个面试题：

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest07 {
    4.     public static void main(String[] args) {
    5.         // 创建线程对象
    6.         Thread t = new MyThread3(); // 多态
    7.         // 设置线程名字
    8.         t.setName("zl-gh");
    9.         // 启动线程
    10.         t.start();
    11.  
    12.         // 调用sleep方法
    13.         try {
    14.             // 这段代码不会让线程zl-gh进入休眠状态，和对象没关系
    15.             // t.sleep在执行的时候还是会转换成：Thread.sleep(1000 * 5);
    16.             // 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。
    17.             // 这样代码出现在main方法中，main线程睡眠。
    18.             t.sleep(1000*5);
    19.         } catch (InterruptedException e) {
    20.             e.printStackTrace();
    21.         }
    22.         // 5秒之后这里才会执行。
    23.         System.out.println("Hello World");
    24.  
    25.     }
    26. }
    27.  
    28. class MyThread3 extends Thread{
    29.     public void run() {
    30.         for (int i = 0; i < 10000; i++) {
    31.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    32.         }
    33.     }
    34. }

    3.终止线程的睡眠 

    注意：这个不是终断线程的执行，是终止线程的睡眠（唤醒线程）。

    调用t.interrupt()这种终断睡眠的方式依靠了java的异常处理机制，来终断线程的睡眠

    1. package com.bjpowernode.java.thread;
    2. /*
    3. sleep睡眠太久了，如果希望半道上醒来，你应该怎么办？也就是说怎么叫醒一个正在睡眠的线程？？
    4.  */
    5. public class ThreadTest08 {
    6.     public static void main(String[] args) {
    7.         // 创建线程对象
    8.         Thread t = new Thread(new MyRunnable1());
    9.         // 设置线程名字
    10.         t.setName("zl-gh");
    11.         // 启动线程
    12.         t.start();
    13.  
    14.         // 希望5秒后，zl-gh线程醒来
    15.         try {
    16.             t.sleep(1000*5);
    17.         } catch (InterruptedException e) {
    18.             e.printStackTrace();
    19.         }
    20.         // 终断t线程的睡眠
    21.         // 这种终断睡眠的方式依靠了java的异常处理机制
    22.         // 这里终断，下面catch会打印异常信息
    23.         t.interrupt();
    24.     }
    25. }
    26.  
    27. class MyRunnable1 implements Runnable{
    28.     // 重点：run()当中的异常不能throws，只能try catch
    29.     // 因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。
    30.     public void run() {
    31.         System.out.println(Thread.currentThread().getName()+"--->begin");
    32.  
    33.         try {
    34.             Thread.sleep(1000*60*60*24*365); // 睡眠1年
    35.         } catch (InterruptedException e) {
    36.             //e.printStackTrace(); // 异常信息的打印
    37.         }
    38.  
    39.         // 一年之后才会执行这段代码
    40.         System.out.println(Thread.currentThread().getName()+"--->end");
    41.  
    42.  
    43.  
    44.         // 调用doOther()
    45.      /*   try {
    46.             doOther(); // 在这里只能try
    47.         } catch (Exception e) {
    48.             e.printStackTrace();
    49.         }*/
    50.     }
    51.  
    52.     // 其它方法可以throws
    53.     /*public void doOther() throws Exception{
    55.     }*/
    56. }
    57.

    4.终止线程的执行

    强行终止线程的执行

    在java中怎么强行终止一个线程的执行；利用t.stop()方法
    这种方式存在很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了，线程没有保存的数据将会丢失。不建议使用。

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest09 {
    4.     public static void main(String[] args) {
    5.         // 创建线程对象
    6.         Thread t = new Thread(new MyRunnable3());
    7.         // 设置线程名字
    8.         t.setName("zl-gh");
    9.         // 启动线程
    10.         t.start();
    11.  
    12.         // 5秒之后强行终止zl-gh线程
    13.         try {
    14.             Thread.sleep(5*1000);
    15.         } catch (InterruptedException e) {
    16.             e.printStackTrace();
    17.         }
    18.         // 5秒之后强行终止zl-gh线程
    19.         t.stop(); // 已过时（不建议使用）
    20.     }
    21. }
    22.  
    23. class MyRunnable3 implements Runnable{
    24.     public void run() {
    25.         for (int i = 0; i < 10; i++) {
    26.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    27.             try {
    28.                 Thread.sleep(1000);
    29.             } catch (InterruptedException e) {
    30.                 e.printStackTrace();
    31.             }
    32.         }
    33.     }
    34. }

    合理终止线程的执行（重点）

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest10 {
    4.     public static void main(String[] args) {
    5.         // 创建线程对象
    6.         MyRunnable4 m = new MyRunnable4();
    7.         Thread t = new Thread(m);
    8.         // 设置线程名字
    9.         t.setName("zl-gh");
    10.         // 启动线程
    11.         t.start();
    12.  
    13.         // 5秒之后终止zl-gh线程
    14.         try {
    15.             Thread.sleep(5*1000);
    16.         } catch (InterruptedException e) {
    17.             e.printStackTrace();
    18.         }
    19.         // 终止zl-gh线程
    20.         m.run = false;
    21.     }
    22. }
    23.  
    24. class MyRunnable4 implements Runnable{
    25.  
    26.     // 打一个布尔标记
    27.     boolean run = true;
    28.  
    29.     public void run() { // 是true才会执行线程
    30.         for (int i = 0; i < 10; i++) {
    31.             if(run){
    32.                 System.out.println(Thread.currentThread().getName()+"--->"+i);
    33.                 try {
    34.                     Thread.sleep(1000);
    35.                 } catch (InterruptedException e) {
    36.                     e.printStackTrace();
    37.                 }
    38.             }else{
    39.                 // false就return结束了，在这里可以进行保存数据的操作
    40.                
    41.                 return;
    42.             }
    43.  
    44.         }
    45.     }
    46. }

    5.线程的调度（了解）

    1、常见的线程调度模型有哪些？

    （1）抢占式调度模型：哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些；java采用的就是抢占式调度模型。

    （2）均分式调度模型：平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样；平均分配，一切平等。有一些编程语言，线程调度模型采用的是这种方式。
    2、java中提供了哪些方法是和线程调度有关系的呢？

    （1）实例方法：
              void setPriority(int newPriority) 设置线程的优先级
              int getPriority() 获取线程优先级
              最低优先级1、默认优先级是5、最高优先级10
              优先级比较高的获取CPU时间片可能会多一些。（但也不完全是，大概率是多的） 
    （2）静态方法：
              static void yield()  让位方法
              暂停当前正在执行的线程对象，并执行其他线程
              yield()方法不是阻塞方法；让当前线程让位，让给其它线程使用。
              yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
              注意：在回到就绪之后，有可能还会再次抢到。
    （3）实例方法：
              void join()  合并线程
              例：t.join(); 当前线程进入阻塞，t线程执行，直到t线程结束。当前线程才可以继续

    5.1 线程优先级

    优先级较高的，只是抢到的CPU时间片相对多一些。
    大概率方向更偏向于优先级比较高的。

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest11 {
    4.     public static void main(String[] args) {
    5.         System.out.println("最高优先级"+Thread.MAX_PRIORITY); // 10
    6.         System.out.println("最低优先级"+Thread.MIN_PRIORITY); // 1
    7.         System.out.println("最高优先级"+Thread.NORM_PRIORITY);// 5
    8.  
    9.         // 获取当前线程对象，获取当前线程的优先级
    10.         Thread currentThread = Thread.currentThread();
    11.         System.out.println(currentThread.getName()+
    12.         "线程的优先级是"+currentThread.getPriority()); // main线程的优先级是5
    13.  
    14.         // 设置主线程的优先级为1
    15.         Thread.currentThread().setPriority(1);
    16.  
    17.         // 调用下面的线程
    18.         Thread t = new Thread(new MyRunnable5());
    19.         t.setPriority(10); // t线程优先级设置为10
    20.         t.setName("zl-gh");
    21.         t.start();
    22.  
    23.         // 主线程的for循环
    24.         for (int i = 0; i < 1000; i++) {
    25.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    26.         }
    27.     }
    28.  
    29. }
    30.  
    31. class MyRunnable5 implements Runnable{
    32.     public void run() {
    33.         // 获取线程默认的优先级
    34.         // System.out.println(Thread.currentThread().getName()+"线程的优先级"+Thread.currentThread().getPriority()); // zl-gh线程的优先级5
    35.  
    36.         // t线程的for循环；优先级较高，抢夺的CPU时间片也多，先执行结束
    37.         for (int i = 0; i < 1000; i++) {
    38.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    39.         }
    40.     }
    41. }

    5.2 线程让位

    让位：当前线程暂停，回到就绪状态，让给其它线程。
    静态方法：Thread.yield();

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest12 {
    4.     public static void main(String[] args) {
    5.         // 创建线程对象
    6.         Thread t = new Thread(new MyRunnable6());
    7.         // 修改线程名字
    8.         t.setName("zl-gh");
    9.         // 启动线程
    10.         t.start();
    11.  
    12.         for (int i = 1; i <= 10000; i++) {
    13.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    14.         }
    15.     }
    16.  
    17. }
    18.  
    19. class MyRunnable6 implements Runnable{
    20.     public void run() {
    21.         for (int i = 1; i <= 10000; i++) {
    22.             // 每100个让位一次
    23.             if(i%100 == 0){
    24.                 Thread.yield();// 当前线程暂停一下，让给主线程。
    25.             }
    26.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    27.         }
    28.  
    29.     }
    30. }

    5.3 线程合并

    实例方法：void join()  合并线程

    1. package com.bjpowernode.java.thread;
    2.  
    3. public class ThreadTest13 {
    4.     public static void main(String[] args) {
    5.         System.out.println("main begin");
    6.         // 创建线程对象
    7.         Thread t = new Thread(new MyRunnable7());
    8.         // 修改线程的名字
    9.         t.setName("zl-gh");
    10.         // 启动线程
    11.         t.start();
    12.  
    13.         // 合并线程
    14.         try {
    15.             // t合并到当前线程中，当前线程受阻塞，t线程执行直到结束。
    16.             t.join();
    17.         } catch (InterruptedException e) {
    18.             e.printStackTrace();
    19.         }
    20.  
    21.         System.out.println("main over"); // 最后执行
    22.     }
    23. }
    24.  
    25. class MyRunnable7 implements Runnable{
    26.     public void run() {
    27.         for (int i = 0; i < 10000; i++) {
    28.             System.out.println(Thread.currentThread().getName()+"--->"+i);
    29.         }
    30.     }
    31. }

    结束语

    今天的分享就到这里啦！快快通过下方链接注册加入刷题大军吧！各种大厂面试真题在等你哦！
    💬刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习

  • 相关阅读:
    JavaScript 35 JavaScript 逻辑
    pytorch 初始化
    GEE4：FCMASK算法进行去云处理
    MetaMask-RPC API
    Spring.Boot Web 模板引擎和首页为什么默认的是index.html页面呀《课时十》
    TextChanged
    docker镜像仓库harbor之清理镜像
    StrongSORT（deepsort强化版）浅实战＋代码解析
    MR混合现实在石油化工课堂教学中的应用演示
    VictoriaMetrics之vmagent
  • 原文地址：https://blog.csdn.net/m0_61933976/article/details/125970340