【第八章】多线程(一)

【第一章】多线程(一)

多线程是在高并发程序开发中的核心,本文就通过来讲解多线程的相关知识来带大家学习多线程与高并发的开发模式。

进程与线程

在开始之前,要先介绍进程与线程的概念。一个进程通常包含以下内容:

一个进程通常包含这些内容:

  1. 程序代码
    也就是这个程序要执行的指令,比如登录、发送消息、显示界面等逻辑。
  2. 数据
    程序运行时需要保存的数据,比如用户信息、聊天记录缓存、当前窗口状态等。
  3. 内存空间
    每个进程都有自己相对独立的内存区域,避免不同程序之间随便互相修改数据。
  4. 系统资源
    比如打开的文件、网络连接、窗口、摄像头、数据库连接等。
  5. 执行状态
    操作系统会记录这个进程现在是在运行、等待、暂停,还是已经结束。

从操作系统角度看,进程是"资源分配的基本单位"。

我们可以把进程理解为正在运行中的程序。进程依靠操作系统调度。也就是说,操作系统管理的是进程。

线程

线程可以理解为:进程内部真正执行任务的单位。

如果说进程像一个"工厂",拥有独立的场地、设备和资源,那么线程就像工厂里的"工人",负责具体干活。

一个进程里面至少有一个线程,也可以有多个线程。而CPU在进行调度的时候,就是以线程为基本单位进行调度。CPU 最终执行的是线程;进程提供线程运行所需的资源环境。


线程在Java中的应用

在Java中,线程通常是由类Thread来表示。在实际开发中,我们常常使用自定义的类来继承类Thread,实现对其功能上的拓展。

java 复制代码
class MyThread extends Thread{

    @Override
    public void run(){
        while(true)
        {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("这是Thread当中的方法");
        }
    }
}

上面的代码是在进行一个新的线程的启动。我们通过重写Thread中的run方法来进行重写,我们开始跑一个线程的时候是通过run方法。这时我们创建的依然是单线程程序

但是上面仅仅是进行一个线程,但是如果我们要新建一个线程的话。我们通常需要使用start方法。start方法本质上会调用操作系统的原生API从而创建一个新的线程出来。但是一个start针对于一个线程只能够调度一次。通过start方法我们可以实现简单的多线程程序。

java 复制代码
package demo1;
import java.util.Map;
import static java.lang.Thread.sleep;

public class TestDemo1 {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        //myThread.start();
        myThread.run();
        while(true)
        {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("这是main当中的方法");
        }
    }
}

class MyThread extends Thread{
    @Override
    public void run(){
        while(true)
        {
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("这是Thread当中的方法");
        }
    }
}

上述展示的是使用自定义类来继承Thread类实现多线程程序。我们还可以实现Runnable接口来为Thread类传参,也可以将runnable变成匿名内部类的形式。既然runnable是函数式接口,自然而然的,我们也可以使用lambda表达式来写。

前台线程与后台线程

在我们创建多线程案例时,我们可以把线程分为前台线程和后台线程。它们的区别就是前台线程会阻止整个线程的结束,而后台线程不会。一个进程中往往有多个前台线程,只有所有的前台线程结束,整个进程才会结束。后台线程只是为前台线程服务的,因此也叫做"守护线程"。


线程的阻止与中断

在多线程的实际开发中,其实我们很少用到线程的阻止与中断。但是这里为了知识的完整性,我们还是把这一部分的内容写上去供大家理解参考。

中断的术语是Interrupt,我们也可以把其理解为中断。其实Java中并没有提供强制中断的方法,而是围绕着让"入口方法结束"的方式来写的。

java 复制代码
t.interrupt();

直接这样写即可,这里不是杀死线程,而是让线程身上多了一个被中断的标记。

  • interrupt() 遇到 sleep 会怎样?

如果线程正在 sleep、wait、join 这类阻塞状态下,被其他线程调用 interrupt(),会抛出 InterruptedException。

  • isInterrupted() 和 interrupted() 的区别

Java 里有两个很容易混淆的方法:isInterrupted()和interrupted()

  1. isInterrupted()
    判断某个线程是否被中断。
    不会清除中断标记。
    示例:
java 复制代码
Thread.currentThread().isInterrupted();

如果中断标记是 true,调用后仍然是 true。

  1. interrupted()

这是 Thread 类的静态方法。

它判断的是当前线程是否被中断,并且会清除中断标记。

示例:

java 复制代码
Thread.interrupted();

如果当前线程中断标记是 true,第一次调用返回 true,然后把标记清除。

第二次再调用,可能就返回 false。

也就是说isInterrupted():只查看,不清除而interrupted():查看后清除。

这个概念非常好理解也非常简单,下面是一段示例代码:

java 复制代码
package demo1;

public class Interrupted {
    private static class MyRunnable implements Runnable {
        public volatile boolean isQuit = false;
        @Override
        public void run() {
            while (!isQuit) {//while(!Thread.interrupted)
                System.out.println(Thread.currentThread().getName()
                        + ": 别管我,我忙着转账呢!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()
                    + ": 啊!险些误了⼤事");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyRunnable target = new MyRunnable();
        Thread thread = new Thread(target, "李四");
        System.out.println(Thread.currentThread().getName() + ": 让李四开始转账。");
        thread.start();
        Thread.sleep(10 * 1000);
        System.out.println(Thread.currentThread().getName()
                + ": ⽼板来电话了,得赶紧通知李四对⽅是个骗⼦!");
        target.isQuit = true;
        //thread.interrpted;
    }
}

线程的等待与休眠

在高并发的场景中,多线程程序往往会涉及到线程的等待,即线程的休眠与等待。

线程的等待

线程的等待使用join关键字。由于线程调度的随机性,我们无法确定哪一个线程可以真正的优先执行,但是我们可以通过线程的等待来确定哪一个线程优先结束。

同样的,我们也是通过实例对象名.join 进行调用。在当前线程中使用此语句表示当前线程等待实例对象名所指的线程。

这里的等待是死等,如果被等待的线程没有执行完,等待的线程会一直等下去...两个线程可以互相等待,这就会构成相互等待,也就是死锁问题。

java 复制代码
package demo1;

public class join {
    public static void main(String[] args) throws InterruptedException {
        Runnable target = () -> {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println(Thread.currentThread().getName()
                            + ": 我还在⼯作!");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
               }
             System.out.println(Thread.currentThread().getName() + ": 我结束了!");
        };

         Thread thread1 = new Thread(target, "李四");
         Thread thread2 = new Thread(target, "王五");
         System.out.println("先让李四开始⼯作");
         thread1.start();
         thread1.join();
         System.out.println("李四⼯作结束了,让王五开始⼯作");
         thread2.start();
         thread2.join();
         System.out.println("王五⼯作结束了");
         }
}

这里使用join就是让main线程来等待两份Thread线程。

线程的休眠

线程的休眠是依靠于sleep函数来执行,后面的括号单位为毫秒,代表当前线程休眠多长时间再继续执行。可以理解为定时器,也就是说,线程会从就绪队列进入阻塞队列,在进行完休眠以后在进入就绪队列,这里休眠在上面的代码中有所体现,这里不再举例。

但是注意写InterruptedException.


线程的引用

指向一个 Thread 对象。这个对象代表一个线程。通过变量名,我们可以访问这个线程。所以线程引用本质上就是:保存 Thread 对象地址的变量。

java 复制代码
Thread t = new Thread(() -> {
System.out.println("子线程正在运行");}, "worker");

常见方法:

getName():获取线程名

setName():设置线程名

getState():获取线程状态

getPriority():获取线程优先级

isAlive():判断线程是否还活着

isInterrupted():判断线程是否被中断

线程的引用与Java中的引用类似,这里不再赘述。


线程的状态

Java 线程一共有六种状态:

NEW:新建状态

当我们创建了一个Thread 对象,但还没有调用start() 方法时,线程处于NEW 状态。

java 复制代码
Thread thread = new Thread(() -> {
    System.out.println("线程执行中");
});
System.out.println(thread.getState()); // NEW

此时线程对象已经存在,但 JVM 还没有真正创建对应的执行线程。也就是说,它只是一个普通的 Java 对象,还没有参与 CPU 调度。

RUNNABLE:可运行状态

当调用线程的start() 方法后,线程进入RUNNABLE 状态。

java 复制代码
thread.start();
System.out.println(thread.getState()); // RUNNABLE

需要注意的是,Java 中的RUNNABLE 状态并不等于线程一定正在 CPU 上执行。

它包含两种情况:

  • 线程已经准备好运行,正在等待 CPU 分配时间片;
  • 线程正在 CPU 上实际执行。
    也就是说,在 Java 层面,传统操作系统中的"就绪状态"和"运行状态"都被归入了RUNNABLE 。

BLOCKED:阻塞状态

当一个线程想要进入synchronized 同步代码块或同步方法,但锁已经被其他线程持有时,该线程会进入BLOCKED 状态。

示例:

java 复制代码
synchronized (lock) {
    // 同一时间只能有一个线程进入
}

如果线程 A 已经持有lock ,线程 B 也想进入这段同步代码,线程 B 就会被阻塞,直到线程 A 释放锁。

BLOCKED 状态的核心原因是:

线程正在等待获取监视器锁,也就是 synchronized 使用的对象锁。

需要注意,BLOCKED 通常特指等待进入synchronized 临界区,而不是所有"等待"都叫BLOCKED 。

WAITING:无限期等待状态

当线程主动进入等待,并且没有指定等待时间时,会进入WAITING 状态。

常见触发方式包括:

java 复制代码
object.wait();
thread.join();
LockSupport.park();

例如:

java 复制代码
synchronized (lock) {
    lock.wait();
}

此时线程会一直等待,直到其他线程通过特定方式唤醒它。

例如:

  • object.wait() 需要通过object.notify() 或object.notifyAll() 唤醒;
  • thread.join() 需要等待目标线程执行结束;
  • LockSupport.park() 需要通过LockSupport.unpark(thread) 唤醒。
    WAITING 的特点是:线程不会主动恢复运行,必须依赖其他线程的通知或特定条件达成。

TIMED_WAITING:限时等待状态

TIMED_WAITING 和WAITING 类似,区别在于它有明确的等待时间。

常见触发方式包括:

java 复制代码
Thread.sleep(time);
object.wait(time);
thread.join(time);
LockSupport.parkNanos(time);
LockSupport.parkUntil(time);

例如:

java 复制代码
`Thread.sleep(1000);`

这表示当前线程暂停 1 秒,在这段时间内线程处于TIMED_WAITING 状态。

时间结束后,线程不会立刻执行,而是重新进入可运行状态,等待 CPU 调度。

需要注意:

sleep() 不会释放锁。

wait(time) 会释放当前对象锁。

这是二者非常重要的区别。

TERMINATED:终止状态

当线程的run() 方法执行完毕,或者执行过程中出现未捕获异常导致线程退出时,线程进入TERMINATED 状态。

java 复制代码
Thread thread = new Thread(() -> {
    System.out.println("线程执行完成");
});

thread.start();

当run() 方法结束后,该线程生命周期结束。

处于TERMINATED 状态的线程不能再次启动。如果再次调用start() ,会抛出异常:java.lang.IllegalThreadStateException

因此,一个Thread 对象只能启动一次。


本章作为多线程的开篇,我们为大家介绍了多线程的一些详细的基础知识,不仅包括了线程的创建与调用,还有多线程下的各种线程状态。喜欢的读者记得给个三连呦~下一篇我们从线程安全问题来给大家介绍

相关推荐
用户548178459095024 分钟前
Java 与 Python 在大模型与智能体领域的选型
java·python
文丑颜不良啊26 分钟前
LeetCode3341~3360题目解析
java·leetcode
hai_android1 小时前
一行 asLiveData,背后是一座生命周期的桥
android·java·kotlin
yiangL_1 小时前
1、Python 输入输出实验|print 与 input 人机交互实践
开发语言·python·人机交互
用户9338104348451 小时前
MyBatis-Plus LambdaQueryWrapper 隐式转换踩坑:不知不觉索引失效
java
用户3721574261351 小时前
Java 在 PDF 中查找关键词:获取页码和坐标,并高亮匹配结果
java
AI工具挖掘机1 小时前
照片转成实况图,发小红书前怎么确认还能动?
经验分享
Forget the Dream1 小时前
Spring AI 2.0 系列(三):ChatClient 与 ChatModel:Spring AI 2.0 的两层职责
java·人工智能·spring·springai
星恒随风2 小时前
MySQL 从零入门(九):事务管理详解——ACID、COMMIT、ROLLBACK、SAVEPOINT 与四种隔离级别
linux·服务器·数据库·笔记·mysql