『Java练习生的自我修养』java-se进阶¹ • 初识多线程

☕☕ Java进阶攻坚克难，持续更新，一网打尽IO、注解、多线程…等java-se进阶内容。

🐋线程的基本概念

🎈程序、进程、与线程？

👉🏻想要搞明白什么是线程，首先要对程序与进程有一个清晰的概念，大学课堂上的《操作系统》这门课开篇就是这部分内容，学过这门课的同学对程序、进程和线程应该已经不陌生了。

程序（program）： 为完成特定任务，用某种语言编写的一组指令集合，程序是静态的，这是它与进程的区别。

进程（process）： 程序的一次执行过程，或是正在运行的一个程序，进程强调的是动态的过程。

👉🏻在不引入线程这个概念之前，进程是系统运行时资源分配和调度的基本单位。为了充分利用系统资源，提高程序的运行效率，将进程进一步细化为线程，取代进程成为了调度和执行的基本单位。

✨线程（Thread）的特点：

1. 线程是程序内部的一条执行路径；
2. 每个线程拥有独立的运行栈和程序计数器（PC），线程之间切换的开销小；
3. 一个进程中的多个线程共享相同的内存单元，可以访问相同的变量和对象；
4. 线程之间的通信简便、高效，但是多个线程访问同一资源时也会带来安全隐患。
5. 如果只有一个CPU时，多线程是模拟出来的，只能称作并发执行，当有多个CPU即多核的状态下，多个线程才是真正的同时执行，可以称作并行。

🎈并行与并发的区别

并行： 多个CPU同时执行多个任务。

并发： 一个CPU同时执行多个任务。这里的“同时”并不是真的有多个任务在同时执行，CPU在一次还是只能执行一个任务，每个任务执行一段时间后就切换其他任务，只不过CPU的速度很快，看起来像是多个任务在同时执行。（操作系统讲到的CPU时间片轮转调度算法就是典型的并行执行例子）

🎈线程的几种状态

🎈何时需要多线程？

1. 程序需要同时执行两个或多个任务；
2. 程序需要实现一些需要等待的任务，比如用户输入，文件读写，搜索等等；
3. 需要后台运行的程序…

🦮线程的创建与使用

👉🏻JVM启动我们的Java程序以后，进程中会有默认的线程，比如Main主方法线程与GC垃圾回收线程。通常我们编写的代码都是在Main主方法线程中执行的，又称作用户线程，而GC垃圾回收线程称作守护线程。

✨Java中想要自己创建线程，有以下三种方式：✨

1. Thread class —▶ 继承Thread类
2. Runnable接口 —▶ 实现Runnable接口
3. Callable接口 —▶ 实现Callable接口

🎯1.继承Thread类

继承Thread类，并重写其中的run()方法，通过调用start()方法开启线程。

//    方式一：继承Thread类//    1.创建子类class MyThread extends Thread{//    2.重写run()方法    @Override    public void run() { System.out.println("创建一个线程");    }}public class Test {    public static void main(String[] args) {// 3.创建对象 MyThread myThread = new MyThread();// 4.调用start（） myThread.start();    }}

写一个小Demo，看一下我们自己创建的线程与主方法线程在运行时的顺序：

（为了避免CPU运行速度过快看不出多线程的效果，可以将循坏次数设置的大一些）

class MyThread extends Thread{    @Override    public void run() { for (int i = 0; i < 300; i++) {     System.out.println("*这是自己创建的线程*MyThread---"); }    }}public class Demo {    public static void main(String[] args) { new MyThread().start(); for (int i = 0; i < 300; i++)     System.out.println("*这是主方法默认线程*Main---");    }}

运行，可以看到即便代码中是先运行MyThread线程，但是两个线程中的输出语句是交替出现的。

🎯2.实现Runnable接口

声明实现类Runnable接口，并实现其中的run()方法，然后分配类的实例，在创建Thread时作为参数传递（这里用了静态代理设计模式），调用Thread下的start()方法启动。

//  方式二：实现Runnable接口class MyThread implements Runnable {//    实现run()方法线程体    @Override    public void run() { System.out.println("创建一个线程");    }}public class Test {    public static void main(String[] args) {// 2.创建Runnable接口的实现类对象 MyThread myThread = new MyThread();// 3.创建线程对象并传递参数，通过线程对象开启我们的线程 new Thread(myThread).start();    }}

使用匿名内部类的方式传递Runnable接口的实现类，让代码更简洁灵活：

public class Test {    public static void main(String[] args) { new Thread(new Runnable() {     @Override     public void run() {  System.out.println("创建一个线程");     } }).start();    }}

JDK1.8新特性，通过Lambda表达式进一步简化代码：

public class Test {    public static void main(String[] args) { new Thread(() -> {     System.out.println("创建一个线程"); }).start();    }}

🎯3.实现Callable接口

Callable接口创建线程的流程：

实现Callable接口→重写call方法→创建目标对象→ 创建执行服务→提交执行→获取结果→关闭服务

import java.util.concurrent.*;//  方式三：实现Callable接口//     实现Callable接口class TestCallable implements Callable<Boolean> {    //    实现call()方法，执行结束后返回一个值    @Override    public Boolean call() throws Exception { System.out.println("创建一个线程"); return true;    }}public class Test {    public static void main(String[] args) throws ExecutionException, InterruptedException {// 创建目标对象 TestCallable t = new TestCallable();// 创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(1);// 提交执行 Future<Boolean> r = ser.submit(t);// 获取结果 boolean res = r.get();// 关闭服务 ser.shutdown();    }}

🐈线程方法

调用线程方法可以控制线程的运行状态：

停止线程：

• JDK提供的stop()、destroy()方法已经废弃，不推荐使用。
• 推荐让线程自己停下来。
• 建议使用一个标志位，当flag=false时终止线程运行。

🍦Demo案例：

class MyThread implements Runnable {//    1.设置一个标志位    private boolean flag = true;    @Override    public void run() { int i = 0; while (flag) {     System.out.println("Thread is running..." + i++); }    }//    2.设置一个公开的方法停止线程，转换标志位    public void stop() { this.flag = false;    }}public class TestStop {    public static void main(String[] args) { MyThread myThread = new MyThread();// 运行myThread线程 new Thread(myThread).start();// 当主线程循环到180次时结束myThread for (int i = 0; i < 300; i++) {     System.out.println("*main*" + i);     if (i == 180) {  myThread.stop();  System.out.println("myThread线程已经停止");     } }    }}

🍦运行结果：

线程休眠：

• sleep(long millis)指定当前线程阻塞的毫秒数。
• sleep(long millis)方法存在异常InterruptedException。
• sleep时间达到后线程进入就绪状态。
• sleep可以模拟网络延时、倒计时等。
• 多线程环境下，每个对象都有一个锁，sleep不会释放锁。

🍦Demo案例：

import java.text.SimpleDateFormat;import java.util.Date;public class TestSleep {//    打印当前系统时间    public static void main(String[] args) throws InterruptedException {// 获取当前时间 Date time = new Date(System.currentTimeMillis()); while (true) {//     每隔1s打印一次时间     Thread.sleep(1000);     System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));//     更新时间     time = new Date(System.currentTimeMillis()); }    }}

🍦运行结果：

线程礼让：

• 调用yield()方法即可让当前正在执行的线程暂停，但不阻塞。
• 将线程从运行态转为就绪态。
• CPU会重新调度，但线程礼让不一定成功，取决于系统的调度。

强制执行：

• 调用join()方法合并线程，其他线程阻塞，待此线程执行完成后，再执行其他线程。

查看线程状态：

调用getState()方法查看线程状态：

• NEW — 线程尚未启动。
• RUNNABLE — 线程正在执行。
• BLOCKED — 线程被阻塞。
• WATTIGN — 线程正在等待另一个线程执行特定动作。
• TIMED_WATTING — 正在等待另一个线程执行动作到达指定等待时间。
• TERMINATED — 线程已经退出。

🍦示例代码：

public class TestState {    public static void main(String[] args) { Thread myThread = new Thread(() -> {     for (int i = 0; i < 3; i++) {  try {      Thread.sleep(1000);  } catch (InterruptedException e) {      e.printStackTrace();  }  System.out.println("这是一个线程");     } });// 查看线程状态 Thread.State state = myThread.getState(); System.out.println(state);// 观察启动后 myThread.start(); System.out.println(myThread.getState());    }}

🍦输出结果：

NEWRUNNABLE这是一个线程这是一个线程这是一个线程Process finished with exit code 0

线程优先级：

• Java提供线程调度器来监控程序中进入就绪状态的线程，线程调度器按照优先级进行调度，但是需要注意优先级不是一定生效，实际的调度顺序取决与CPU调度，只不过优先级高的被先调度的概率会高一些。
• 线程优先级用数字表示，1~10：
  • Thread.MIN_PRIORITY = 1
  • Thread.MAX_PRIORITY = 10
  • Thread.NORM_PRIORITY = 5
• 获取或改变优先级：
  • getPriority()
  • setPriority(int x)
• 只能先设置优先级再启动线程，反过来不行。

🐄守护线程

👉🏻线程分为用户线程与守护线程，操作日志、内存监控、垃圾回收等都属于守护线程。虚拟机只需要确保用户线程执行完毕，而不用等待守护线程也执行完。

👉🏻通过setDaemon(boolean x)方法设置守护线程，默认值是false，代表用户线程，正常的线程都是用户线程，setDaemon(true)将线程切换为守护线程。

🍦代码示例：

public class TestDaemon {    public static void main(String[] args) {// 设置用户线程执行20次 Thread userThread = new Thread(() -> {     for (int i = 0; i < 20; i++) {  System.out.println("*我是一个用户线程*" + i);     } });// 设置守护线程执行100次 Thread daemonThread = new Thread(() -> {     for (int i = 0; i < 100; i++) {  System.out.println("---我是一个守护线程---" + i);     } });// 将线程设定为守护线程 daemonThread.setDaemon(true); userThread.start(); daemonThread.start();    }}

🍦运行结果：

可以发现即便代码部分守护线程循环了100次，但是用户线程结束，整个程序都会结束，JVM不会再等待守护线程也执行完。

🦌线程池技术

如果用过数据库连接池的同学对线程池也有一定概念了，它们都属于池化技术，目的就是提高程序的性能。

📍为什么需要线程池？

频繁创建和调用线程尤其是并发情况下的线程，对性能的影响很大。如果提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回线程池中，可以有效避免线程的频繁创建销毁，实现重复利用。

📍引入线程池技术的好处：

• 降低资源消耗。
• 便于线程管理。
• 提高响应速度，减少创建新线程的时间。

📍使用线程池：

JDK5.0版本提供的线程池工具类：ExecutorService 和 Executors，其中Executors是线程池的工厂类，用于创建并返回不同类型的线程池，ExecutorService是真正的线程池接口。

• Executors.newFixedThreadPool(int parm)方法返回一个线程池池，参数执行线程池的大小。
• ExecutorService类下的execute(Runnable command)方法用于将线程丢进线程池并执行线程。
• 线程执行完毕后可以使用shutdown()方法关闭线程池链接。

🍦线程池编程3步：

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;class MyThread implements Runnable {    @Override    public void run() {// 循环输出线程名称+循环次数 for (int i = 0; i < 10; i++) {     System.out.println(Thread.currentThread().getName() + " :" + i); }    }}public class Demo {    public static void main(String[] args) {// 1.创建线程池 ExecutorService service = Executors.newFixedThreadPool(10);// 2.将线程丢进线程池并启动 service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread()); service.execute(new MyThread());// 3.关闭线程池链接 service.shutdown();    }}

🍦执行结果：

💙🧡💙🧡💙🧡💙🧡💙 🤍💬下篇预告：并发与多线程🤍 💛💚💛💚💛💚💛💚💛

🍍🍍🍍
创作不易，如果觉得本文对你有所帮助，欢迎点赞、关注、收藏。🙇🏻‍♀️
🍉🍉🍉
@作者：Mymel_晗，计算机专业练习时长两年半的Java练习生~🏃🏻‍♂️🏀

🔸🔹文末已至，咱们下篇再见🔹🔸

创作打卡挑战赛 赢取流量/现金/CSDN周边激励大奖