小工具知识网

当前位置: 首页 > 行业知识 > 【JavaSE】多线程

行业知识

【JavaSE】多线程

2026-10-25 18:12:43 来源:互联网转载

目录

  • 进程与线程
    • 进程
    • 线程
    • 几个基本概念
      • 串行和并行
      • 并行与并发
      • 多线程
        • 概念
        • 多线程的优点/好处
        • 多线程问题分析
        • Java多线程的基本使用
          • Thread类
          • 主线程
          • 守护线程
            • 案例:显示主线程名
            • 多线程实现方式
              • 继承java.lang.Thread类
                • 步骤
                • 代码实现
                  • start()和run()的区别?
                  • 注意
                  • 实现Runnable接口创建线程
                    • 步骤
                    • 代码实现
                    • 实现Callable接口
                      • 步骤
                      • 代码实现
                      • 线程状态
                        • CPU执行原理
                          • 补充
                          • 线程调度
                            • 线程优先级
                            • 线程休眠|sleep()
                            • 线程的强制运行|join()
                              • 分析
                              • 线程的礼让|yield()
                              • 面试题:sleep()和yield()的区别
                              • 线程中断|interrupt()
                              • 线程等待|wait()
                                • wait()方法的主要功能
                                • wait()做的三件事
                                • 代码案例
                                • 线程唤醒
                                  • notify()方法
                                    • 代码实现
                                    • notifyAll()方法
                                      • 代码实现
                                      • 面试题:wait和sleep的区别
                                      • 多线程JVM内存分配
                                      • 线程安全
                                        • 案例分析
                                          • 代码
                                          • 变量对线程安全的影响
                                          • 线程同步
                                            • 与异步的区别
                                            • 同步代码块
                                              • 原理:
                                              • 同步方法
                                              • 如何解决线程安全问题
                                              • lock方式
                                                • 代码实现
                                                • lock和同步块比较
                                                • 总结
                                                • ***锁
                                                  • ***锁的产生
                                                  • 案例代码
                                                  • 解决方案
                                                    • 代码示例
                                                    • 守护线程
                                                      • 守护线程的特点:
                                                      • 守护线程用在什么地方呢?
                                                      • 线程池
                                                        • 线程池的工作机制
                                                        • 线程池优点
                                                        • 线程池的构造方法
                                                        • 案例分析
                                                        • 线程池的状态
                                                        • 线程池的主要流程
                                                          • 拒绝策略
                                                          • 提交任务
                                                          • 各种线程池使用
                                                            • 1.单一线程池
                                                              • ExecutorService的submit和execute方法区别
                                                              • 2. 固定线程池
                                                              • 3. 可变线程池
                                                              • 4. 定时线程池(任务调度线程池)
                                                                • 线程池的关闭
                                                                • 四种线程池比较
                                                                • 5. SpringBoot中使用自定义线程池
                                                                  • 配置
                                                                    • 配置类
                                                                    • 测试
                                                                    • 运行结果
                                                                    • 补充:线程数据传递
                                                                      • 通过构造方法传递数据
                                                                      • 通过变量和方法传递数据
                                                                      • 通过回调函数传递数据

                                                                        进程与线程

                                                                        进程

                                                                        • 应用程序的执行实例,有独立的内存空间和系统资源
                                                                        • 当一个程序被运行,那么就相当于在这台电脑上开启了一个进程,比如我们可以看到任务管理器中的IDE,Firefox,WPS,微信等
                                                                        • 程序由指令和数据组成;指令要运行,数据要加载;指令被CPU加载运行,数据被加载到内存;指令运行时可由CPU调用硬盘、网络等设备

                                                                          线程

                                                                          • CPU调度和分派的基本单位,进程中执行运算的最小单位,可完成一个独立的顺序控制流程
                                                                          • 一个进程内可以分为多个线程
                                                                          • 一个线程就是一个指令流,CPU调度的最小单位,由CPU一条一条的执行指令

                                                                            几个基本概念

                                                                            串行和并行

                                                                            • 串行:相对于单条线程来执行多个任务来说,以下载文件为例,当下载多个文件时,一般理解和操作就是按照一定顺序进行下载,也就是说,有A,B,C三个文件时,必须等A下载完之后才能去下载B,然后B下载完才能下载C,他们在时间上不可能重叠

                                                                            • 并行:下载多个文件时,开启多条线程,多个文件同时进行下载,这里是同一时刻发生的,并行在时间上是重叠的

                                                                              并行与并发

                                                                              • 并发:单核CPU运行多线程时,时间片进行很快的切换,多个线程轮流执行CPU
                                                                              • 并行:多核CPU运行,多线程时,真正的在同一时刻运行

                                                                                多线程

                                                                                概念

                                                                                • 如果在一个进程中同时运行了多个线程,用来完成不同的工作,则称之为“多线程”
                                                                                • 多个线程交替占用CPU资源,而非真正的并行执行

                                                                                  多线程的优点/好处

                                                                                  1. 充分利用CPU的资源
                                                                                  2. 简化编程模型
                                                                                  3. 带来良好的用户体验

                                                                                  多线程问题分析

                                                                                  • 先说单线程,从流程上来看,单线程只有一条之执行线,过程直观,很好理解代码的执行过程
                                                                                  • 多线程是多条执行线,企鹅一般多条执行线之间有所交互,多条执行线之间可能需要通信,因此会产生以下问题
                                                                                    • 多线程的执行结果不确定,因为受到CPU调度的影响
                                                                                    • 多线程引发的安全问题(如资源共享问题)
                                                                                    • 线程资源比较宝贵,依赖线程池操作线程,线程池的参数如何设置是个问题
                                                                                    • 多线程的执行是动态的,且几乎是同时的,难以追踪过程
                                                                                    • 多线程的底层是操作系统层面,源码难度大

                                                                                      Java多线程的基本使用

                                                                                      Thread类

                                                                                      • Java提供了java.lang.Thread类支持多线程编程

                                                                                        主线程

                                                                                        • main()方法即为主线程入口
                                                                                        • 产生其他子线程的线程
                                                                                        • 必须最后完成执行,因为它执行各种关闭动作

                                                                                          守护线程

                                                                                          • 也叫后台线程,如:jvm的垃圾回收线程、jvm的异常处理线程。

                                                                                            案例:显示主线程名

                                                                                            public static void main(String args[]) {Thread t= Thread.currentThread(); System.out.println("当前线程是: "+t.getName()); t.setName("MyJavaThread"); System.out.println("当前线程名是: "+t.getName()); }

                                                                                            多线程实现方式

                                                                                            1. 继承Thread类 (可以说是 将任务和线程合并在一起)
                                                                                            2. 实现Runnable接口 (可以说是 将任务和线程分开了)
                                                                                            3. 实现Callable接口 (利用FutureTask执行任务)
                                                                                            4. 线程池

                                                                                            继承java.lang.Thread类

                                                                                            步骤
                                                                                            1. 自定义一个类MyThread类,用来继承与Thread类
                                                                                            2. 在MyThread类中重写run()方法
                                                                                            3. 在测试类中创建MyThread类的对象
                                                                                            4. 启动线程:start()
                                                                                            代码实现

                                                                                            线程类

                                                                                            public class MyThread01 extends Thread{    @Override    public void run(){        for (int i = 1; i             Thread.currentThread().setName("线程1:");            System.out.println(Thread.currentThread().getName() + i);        }    }}public class MyThread02 extends Thread{    @Override    public void run(){        for (int i = 1; i             Thread.currentThread().setName("线程2:");            System.out.println(Thread.currentThread().getName() + i);        }    }}    public static void main(String[] args) {        MyThread01 myThread01 = new MyThread01();        //myThread01.run();        MyThread02 myThread02 = new MyThread02();        myThread01.start();//启动线程        myThread02.start();//启动线程        for (int i = 1; i             System.out.println(Thread.currentThread().getName() + i);        }    }}    @Override    public void run() {        for (int i = 0; i 

上一篇:服务器怎么开新服账号啊?

下一篇:子服务器怎么部署?