˃͈꒵˂͈꒱ write in front ꒰˃͈꒵˂͈꒱
ʕ̯•͡˔•̯᷅ʔ大家好，我是xiaoxie.希望你看完之后,有不足之处请多多谅解，让我们一起共同进步૮₍❀ᴗ͈ . ᴗ͈ აxiaoxieʕ̯•͡˔•̯᷅ʔ—CSDN博客
本文由xiaoxieʕ̯•͡˔•̯᷅ʔ 原创 CSDN 如需转载还请通知˶⍤⃝˶​
个人主页：xiaoxieʕ̯•͡˔•̯᷅ʔ—CSDN博客

系列专栏:xiaoxie的JAVAEE学习系列专栏——CSDN博客●'ᴗ'σσணღ
我的目标:"团团等我💪( ◡̀_◡́ ҂)" 

( ⸝⸝⸝›ᴥ‹⸝⸝⸝ )欢迎各位→点赞👍 + 收藏⭐️ + 留言📝​+关注（互三必回）!

目录

​编辑一.线程

  1.什么是线程

2.进程和线程的区别

1.在这里先解释一下最基础的定义

2.举个我们日常生活中的小例子

3.线程和进程的区别以及线程相比于进程的优点:(这个面试中也算是比较高频的问题)

二.编写多线程代码

1.定义线程类

1.说明

2.通过实现Runnadle接口创建线程

3.针对方法1使用匿名内部类

 4.针对方法2使用匿名内部类

5.使用 lambda表达式

三.Thread类

1.构造方法

2.其他的方法

1.获取Id getid()

 ​编辑  2.获取名称 getName()

3.获取状态 getState()

4.是否为后台线程 isDaemon()

​编辑 5.是否存活 isAlive()

6.是否被中断 isInterrupted()

---

一.线程

  1.什么是线程

线程（Thread）是程序中执行的最小单元，是操作系统能线程是计算机科学中的基本概念，指的是在同一进程中执行的单一执行流。线程是操作系统能够进行运算调度的最小单位。在多线程编程中，多个线程可以同时执行，共享进程的资源，但每个线程有自己的执行流程和栈空间。线程的引入可以提高程序的并发性和响应性，允许程序在同一时间处理多个任务。

在计算机系统中，线程是由操作系统调度和管理的，可以实现不同线程之间的切换和协同工作。线程之间可以共享进程的资源，如内存空间、文件描述符等，但也需要注意线程之间的同步和互斥，以避免竞态条件和数据不一致问题。

在编程中，线程可以用来实现并发编程，允许程序同时执行多个任务，提高程序的性能和效率。常见的多线程编程模型包括线程池、生产者-消费者模型等

2.进程和线程的区别

这个先解释一下线程和进程的区别,这个两个词虽然看起来相差不大,但意思却相差很大,当对于初学者来说还是比较容易混淆的

1.在这里先解释一下最基础的定义

    进程：在计算机操作系统中，进程是对运行中程序的一个抽象，它是系统进行资源分配和调度的基本单位。每个进程都有自己独立的地址空间，包含了程序代码、数据、打开的文件描述符等资源。当一个程序开始执行时，操作系统会为其创建一个新的进程，使得程序可以占用系统资源并独立运行。

     线程：线程是进程内的一个执行路径，也是CPU调度的最小单位。一个进程中可以有一个或多个线程(每个进程都有最基本的主线程)，这些线程共享进程的相同地址空间（包括代码、全局变量等资源）。每个线程都维护有自己的程序计数器、寄存器集合和栈，这样它们就可以在进程的上下文中并发执行各自的任务。相较于进程，线程之间的切换成本更低，而且由于资源共享的特性，线程间的通信和同步更为简便。

2.举个我们日常生活中的小例子

用日常生活的例子来解释进程和线程的区别：

进程比喻： 想象一个餐厅，每个餐厅就是一个进程，它有自己独立的厨房（资源）、服务员（线程）、菜单（程序）、餐桌（内存空间）和客户账单（数据）。如果有两家不同的餐厅（两个进程），它们各自运营，拥有各自的食材和设备，互不影响，也不能直接共享对方的东西。

线程比喻： 回到同一个餐厅内，如果餐厅有多个服务员（线程），他们共享餐厅的所有资源（如厨房、菜单等），并且能在同一餐厅的不同区域同时服务多个顾客。比如，一个服务员负责点菜（处理请求），另一个负责上菜（执行任务），还有一个负责结账（清理资源）。虽然他们在同一片工作区（地址空间）内同时活动，但会通过合理的协调（例如，加锁机制）来避免冲突。

总结来说，在这个比喻中：

• 进程就像是独立运作的餐厅，每个餐厅有一套完整的设施和人员；
• 线程则是同一餐厅内的不同服务员，他们共享餐厅资源并在其中执行各自的任务，可以同时服务于不同的顾客，实现并发操作。

3.线程和进程的区别以及线程相比于进程的优点:(这个面试中也算是比较高频的问题)

1. 资源分配：

   • 进程：进程是操作系统进行资源分配和保护的基本单位，每个进程都有独立的内存空间，其中包括代码段、数据段、堆和栈。这意味着不同进程之间无法直接访问彼此的内存空间，从而保证了进程间的隔离性。
   • 线程：线程是进程内部的执行实体，是系统调度和分配CPU的基本单位。同一进程内的所有线程共享相同的地址空间（包括全局变量、文件描述符等资源），也就是说，线程间可以直接读写同一进程内的内存，无需通过IPC（进程间通信）机制。

2. 创建和切换开销：

   • 进程：创建新进程需要分配独立的地址空间和其他相关资源，因此开销较大。进程间的切换除了保存和恢复CPU上下文外，还可能涉及虚拟内存、页表等映射的切换，开销相对较高。
   • 线程：创建线程的成本比进程低得多，因为它不需要额外分配地址空间。线程间的切换只需要保存和恢复少量寄存器状态（如程序计数器、栈指针等），因此线程切换的开销较小。

3. 并发性和并行性：

   • 进程：进程提供了并发执行的能力，即在单个处理器上通过时间片轮转实现看似同时运行的效果，而在多处理器环境下，则可以真正地并行执行不同的进程。
   • 线程：线程提供了更加细粒度的并发执行，一个进程中的多个线程可以在单个处理器上通过时间片轮转并发执行，也可以在多核处理器上真正并行执行。

4. 通信与同步：

   • 进程：进程间的通信通常需要使用IPC机制，如管道、信号量、消息队列、共享内存等。
   • 线程：由于同一进程内的线程共享内存空间，它们之间的通信和同步可以通过更简单的机制实现，如锁、条件变量等。

5. 管理复杂性：

   • 进程：进程管理相对复杂，需要考虑资源的独立性和安全性。
   • 线程：线程管理更加灵活，但由于线程间的资源共享特性，可能导致竞态条件和死锁等(涉及到线程安全问题)问题，因此线程同步和互斥问题较为复杂。

综上所述，进程是操作系统中资源分配和保护的基本边界，而线程则是提供更高效并发执行能力的基础，并且在线程之间更容易共享信息和协同工作。

二.编写多线程代码

1.定义线程类

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello Thread");
            try {
                Thread.sleep(1000);//使线程休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
public class Demo1 {

    }
    public static void main(String[] args)  {
        Thread thread = new MyThread();
        thread.start();//创建线程
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果:

 我们可以看到主线程和Thread线程在交替打印各自的信息需要注意的是，实际运行时，由于线程调度机制，线程间的执行并不是严格按照交替顺序进行的，而是随机交错的。

同时我们还可以通过命令行的方式查看线程运行的状态

WIN + R 后输入cmd打开命令行后输入jconsole

点击我们刚才创建好的线程 

 看到这里提醒不安全连接我们不用理会直接点击

 此时我们就清楚的看见线程的状态以及其它信息

1.说明

我们可以看到如果使单线程运行的化,此时陷入了死循环,应该无限循环不断地输出"hello Thread",但就是因为多线程操作并发操作程序实现了两个并发执行的线程：主线程和MyThread子线程。这两个线程交替打印各自的信息，同时还可以发现,打印时并不是严格按照交替顺序进行,而是随机交错但由于线程调度的不确定性，(抢占执行)实际输出的结果可能会出现交错现象，比如连续输出多次"hello Thread"后再输出几次"hello main"，或者是反过来的情况，这就是线程随机交错的现象。

同时在这里解释一下

 1.首先定义了一个名为MyThread的类，该类继承自java.lang.Thread。在MyThread类中重写了run()方法，这个方法是线程需要执行的任务主体。在run()方法内部，有一个无限循环不断地输出"hello Thread"，并且每次循环之间让当前线程睡眠1秒通过Thread.sleep(1000)实现并且实现这个方法需要抛异常。

2.创建线程实例：在main方法中，创建了MyThread类的一个实例thread。启动线程：调用thread.start()方法来启动线程。这会让JVM找到这个线程对象的run()方法，并在一个新的线程上下文中执行它

 为什么要调用thread.start()  (这一点很重要)

在Java中，当你想要启动一个新的线程去执行特定任务时，你需要调用Thread对象的start()方法。这是因为start()方法的作用是让JVM创建一个新的线程，并在这个新线程中调用你之前重写的run()方法。

具体来说：

• 当你创建一个Thread对象实例时，只是在内存中构建了一个表示线程的对象，并没有真正开启一个新的执行流。
• 而当你调用start()方法时，Java虚拟机会为此线程分配必要的系统资源（如内存），并在某个时刻将该线程放入可执行线程队列等待调度。
• 线程调度器会选择合适的时机将该线程从就绪状态转为运行状态，这时run()方法才会在新创建的线程上下文中执行。

因此，如果你直接调用run()方法而不是start()方法，那么代码将在当前线程（通常是主线程）中同步执行，而非异步在新的线程中执行，也就失去了多线程的意义。

2.通过实现Runnadle接口创建线程

class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args)  {
        Thread t = new Thread(new MyThread());
        t.start();
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 定义Runnable接口的实现类：MyRunnable类实现了java.lang.Runnable接口，并在其内部重写了run()方法。这个run()方法同样是线程需要执行的任务主体，这里也是一个无限循环，每秒输出一行空白字符，并在每次循环间使当前线程睡眠1秒。

输出结果和第一种方法同样主线程和Thread线程在交替打印各自的信息,同样不是严格按照交替顺序进行的，而是随机交错的

  

3.针对方法1使用匿名内部类

public class Demo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        t.start();
        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

就是针对方法1的一个变种方法,结果都一样,都是实现了多线程

  

 4.针对方法2使用匿名内部类

public class Demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }

    }
}

 就是针对方法2的一个变种方法,结果都一样,都是实现了多线程

  

5.使用 lambda表达式

public class Demo5 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while (true) {
               System.out.println("hello Thread");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t.start();
        while (true) {
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

Lambda表达式是Java 8及其后续版本引入的一种简洁的函数式编程风格的特性，用于创建匿名函数或闭包。Lambda表达式使得开发者能够更加方便地处理函数式接口（即只有一个抽象方法的接口），无需显式声明新的类来实现这些接口。

基本结构： Lambda表达式的通用格式如下：

Java

1(parameters) -> {body}

• 参数部分（parameters）：可以为空，也可以包含零个或多个参数。每个参数都有一个类型或可以通过类型推断得出。如果只有一个参数，可以省略小括号；如果有多个参数，则需用逗号分隔。

• 箭头符号（->）：标志着参数列表的结束和函数体的开始。

• 函数体（body）：可以是一个表达式或一个代码块。如果函数体只包含一条表达式且能隐式转换为方法的返回类型，可以省略大括号；否则，需要使用大括号包围多条语句形成代码块。

 结果如下:

  

这5种方法博主这里建议大家不说你都会写,(当然这5种方法多写几遍,应该差不多就可以掌握了)但你至少都得看的懂,并且熟练掌握几种.其实这5种方法本质上就是

1.把线程具体要实现的业务写出来即(重写run()方法)

2.通过调用start()方法创建/启动线程.

三.Thread类

1.构造方法

T​​​​hread(String name)这里可以为你创建的线程,命名以便在后续这个名字对于理解和追踪多线程应用程序中的各个线程很有帮助，尤其是在调试和日志记录的过程中。

public class Demo23 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()-> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("hello Thread");
            }
        },"text1");
        t1.start();
        while (true) {
            Thread.sleep(1000);
            System.out.println("hello main");
        }
    }
}

通过命令行输入jconsole打开Java的监视控制台就可以查看到,此时我们创建的线程的状态,非常便于识别和管理各个线程特别是在后期我们创建很多线程时,优势就体现出来了

  

2.其他的方法

1.获取Id getid()

public class Demo23 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()-> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("hello thread");

        },"text1");
        t1.start();
        System.out.println(t1.getId());//获取线程的ID
        Thread.sleep(1000);
        System.out.println("hello main");

    }
}

结果为:

   2.获取名称 getName()

3.获取状态 getState()

4.是否为后台线程 isDaemon()

这里我们介绍一下后台线程和前台线程的区别

1. 前台线程（Foreground Thread）：

   • 常指那些负责处理用户交互、执行主业务逻辑或执行关键服务的线程，这类线程通常决定了整个应用程序的生命周期。例如，GUI应用程序的事件循环线程就是一个典型的前台线程，只要这个线程还在运行，应用程序就不会退出。另外，Web服务器中的请求处理线程也是前台线程，它们必须保持活跃以响应客户端请求。

2. 后台线程（Background Thread）：

   • 也称为守护线程（Daemon Thread）。在Java中，通过调用 Thread.setDaemon(true) 方法可以将一个线程设置为守护线程。守护线程主要用于执行支持性的任务，比如清理工作、资源监控、定时任务等。当所有的非守护线程（也就是所谓的前台线程）都结束后，即使还有守护线程在运行，Java虚拟机也会退出。也就是说，守护线程依赖于非守护线程的存在，非守护线程全部结束后，守护线程也随之结束，不再单独维持应用程序的运行。

总结来说，前台线程与应用程序的主要功能和生命周期紧密相关，而后台线程则更多是服务于前台线程，不直接影响应用程序的关闭与否

为了通俗易懂点博主这里举个小例子

1. 前台线程（重要主线任务）：

   • 假设你正在厨房做饭（这是你的主要任务，类似于前台线程），你正在炒菜（主业务流程），这个过程中你需要不断地翻炒、调味等操作（前台线程的工作）。如果不做这些，饭就无法完成，这就是至关重要的前台任务。

2. 后台线程（辅助支持任务）

   • 同时，厨房里的洗碗机正在运行清洗餐具（这是一个后台守护任务，类似于后台线程）。虽然洗碗很重要，但如果炒菜任务完成了（所有非守护线程结束），你可以离开厨房，即使洗碗机还没洗完（后台线程仍在运行），你也不会留在那里等待它结束。洗碗机就是在后台默默地支持你的主要烹饪任务。

通过这个例子，可以看出前台线程（炒菜）主导着整个活动的进程和结束，而后台线程（洗碗机）虽然重要，但它的运行并不影响整个活动（做饭）的基本结束条件。在计算机程序中，后台线程往往用来处理一些辅助性、长期运行或维护性的工作，而不直接影响程序的主流程和退出。

再通过具体的代码例子来说明后台线程和前台线程

这个属于两个都是前台线程的情况

public class Demo25 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           for(int i = 0; i <5;i++) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               System.out.println("hello Thread");
           }
            System.out.println("t1结束");
        });
        t1.start();
        for (int i = 0;i < 3;i++) {
            Thread.sleep(1000);
            System.out.println("hello main");
        }
        System.out.println("main结束");
    }
}

 

可以看到,main线程以及结束了,可是t1线程没有结束,此时进程就没有结束,直到t1结束后,进程才结束,这就是只有所有前台线程结束后,进程才结束

我们现在把t1线程设置为后台线程再看看结果如何

这里要注意在创建线程之前(在start()方法之前),就要先设置好,否则此操作无效

public class Demo25 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           for(int i = 0; i <5;i++) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               System.out.println("hello Thread");
           }
            System.out.println("t1结束");
        });
        t1.setDaemon(true);//要在线程创建前,将线程设置为后台线程
        t1.start();
        for (int i = 0;i < 3;i++) {
            Thread.sleep(1000);
            System.out.println("hello main");
        }
        System.out.println("main结束");
    }
}

此时,main线程为前台线程,t1为后台线程,我们可以看到只要main线程结束了,无论t1是否结束,进程都结束了.以及如果t1结束,但前台线程main线程没有结束,进程也不会结束

public class Demo25 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
           for(int i = 0; i <3;i++) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               System.out.println("hello Thread");
           }
            System.out.println("t1结束");
        });
        t1.setDaemon(true);//要在线程创建前,将线程设置为后台线程
        t1.start();
        for (int i = 0;i < 5;i++) {
            Thread.sleep(1000);
            System.out.println("hello main");
        }
        System.out.println("main结束");
    }
}

 5.是否存活 isAlive()

它用于检查一个线程是否仍然存活，即线程是否已经开始执行且还没有结束。

6.是否被中断 isInterrupted()

isInterrupted() 是Java中 Thread 类的一个方法，用于检查线程是否已被中断。中断是一种协作机制，允许一个线程通知另一个线程应该停止当前正在执行的操作。

语法如下：

Java

1boolean isInterrupted()

这个方法会返回一个布尔值：

• 如果线程已被中断（调用了 interrupt() 方法），则返回 true；
• 如果线程未被中断，则返回 false。

需要注意的是，调用 isInterrupted() 方法并不会清除中断状态。如果希望在检查中断状态的同时清除此状态，可以使用静态方法 Thread.interrupted()。

举例说明：

Java

1Thread thread = new Thread(() -> {
2    while (!Thread.currentThread().isInterrupted()) {
3        // 执行任务...
4    }
5});
6
7thread.start();
8
9// 在某个时刻，决定中断线程
10thread.interrupt();
11
12// 另一线程或同一线程中的代码可以通过isInterrupted()检查中断状态
13if (thread.isInterrupted()) {
14    System.out.println("线程已被中断");
15}

在上面的代码中，线程在执行任务时会周期性检查自身的中断状态，一旦发现被中断，就会退出循环，从而达到协作式中断的目的

同时需要注意的是,只能起到提醒作用,并不可以真正的中断,这能该线程自己中断自己

例如，线程可能在循环、等待IO操作、或者在调用 sleep()、wait()、join() 等方法时被中断。在这些情况下，被中断的线程通常会抛出一个 InterruptedException 异常，然后可以根据程序的需求选择恢复执行、清理资源后退出，或者直接结束线程。

总的来说，interrupt() 方法和 isInterrupted() 方法提供了线程间的通信手段，允许一个线程请求另一个线程停止其当前的操作，但具体的中断逻辑需要由被中断线程自行实现，体现了Java中线程中断的协作性和灵活性。

以上就是博主关于Java多线程学习的一点点部分,后续还有很多内容,例如重点的:线程安全问题

这里就不过多的赘述了,如果感兴趣的话,可以关注博主.查看线程安全的解释