基础篇-容器

文章详细介绍了ArrayList的扩容规则,初始为0,首次扩容为10,后续每次1.5倍增长。LinkedList的查询和插入性能特点,以及HashMap的实现原理,包括二次哈希解决冲突,链表转红黑树的策略,以及1.7和1.8版本的区别。同时提到了HashMap的线程安全问题和死链现象。

 1.ArrayList扩容规则

知识点1:无参构造器的初始值为0

 知识点2:第一次扩容就会创建一个长度为10的数组
         第二次后扩容就会是上次的1.5倍(第二次数组长度就是10*1.5=15 
 注意:新的数组会代替旧的数组,旧的数组会被垃圾回收掉)

第二次扩容计算:
15>>1
7
15+7
22
前20次扩容的数组长度的打印:

addAll():
    1.list如果小于10,第一次扩容是10;
    2.扩容规则:下次扩容的大小和数组的长度中取较大值;

 

 总结:

 迭代器:

 

 

 

 failSafe:

 重复刚才的过程:

 **34-35 .FailFast源码分析

2.LinkedList

ArrayList:是基于内存存储连续存储 可以通过简单的计算可以算出内存地址
比如:第一个元素地址是0  每个地址都是30个字节   第四个下标的地址是:0+4*30=120
LinkList:比如也找到4,先从1找到2的地址,然后从2找到3的地址,从3找到4的地址;

 

 **36.04.00 -05.26 讲解源码

随机查询:AraryList性能更好

后面一样查询性能

LinkedList中间插入慢的原因:查找需要一个一个找到,极其消耗性能

ArrayList头部插入或者其他非尾部查询需要复制一份,然后进行数据替换,性能比较慢

 ** 38  空间占用原理讲解

3.HashMap

 3.1  HashMap的实现原理

计算原则:a 进行hashcode 97,然后二次hash得到 97 ,然后将97 和 数组长度16 进行取模得到1
这时候1就是a的下标

ArrayList获取a需要遍历查询,这种情况HashMap效率高的多

 3.2  链表过长的解决方案

链表过长的解决方案:
   1.扩容 当数组大于3/4被使用就会被扩容(数组长度是16的话,链表有13个元素就会被扩容 
   注意:扩容之后下标需要重新计算 如图1)
   2.红黑树  
   需要同时满足两个条件:1.链表长度大于8  2.数组容量必须大于64  如图2
   红黑树特点:是二叉树,左边小右边大,时间复杂度是O(logn),效率比链表高
   注意:链表查询的时间复杂度O(n) 链表(node)占用的内存没有红黑树(TreeNode)多
   正常情况下链表的长度不会大于8,主要防止黑客恶意攻击影响整个系统的性能 如图3
   红黑树何时退化成链表:
      

图1.

 图2.

 图3.

 图4.

 退化成链表:

 

 图5

3.3  索引是如何计算的

分布比较均匀的情况(正例):

 分布不均匀的情况(反例):

 原因:这些数据第一位都相同导致对16进行取模得到的数字都一样 解决方案:以jdk1.8为例 

 添加二次hash后,反例变均匀:

图6. 

 

 3.5 HashMap1.7和1.8的不同

 注意:扩容是添加完之后进行扩容

 

注意:1.7扩容的问题:扩容后遵循 头插法导致扩容之后顺序变了,这就会导致死链问题

           1.8在扩容计算node索引时,会优化:           

           按位与计算:如何是0则不用动位置,如果不为0则计算新的位置旧的位置+按位索引 

 3.6 HashMap负载因子的设计

 

注意:类型设置为Thread 

注意:多线程很有可能出现丢数据的问题,如上图这两个都有可能同时运行631行代码,导致前面的key被覆盖。 

 **p53.1.7死链

 

注意:1.字符串如果多个可以通过这个散列公式计算出对应的hashcode,得到足够混匀的hash值

           2.31优化更好可以用按位与进行运算 

基础-0-Java虚拟机导学课程 11:33 基础-1-初识JVM 22:27 基础-2-Java虚拟机的组成 04:47 基础-3-字节码文件的组成-以正确的姿势打开字节码文件 10:41 基础(补)-3.5-字节码文件的组成-基础信息 15:54 基础-4-字节码文件的组成-常量池和方法 25:51 基础-5-字节码文件常见工具的使用1 11:43 基础-6-字节码文件常见工具的使用2 22:20 基础-7-类的生命周期加载阶段 22:09 基础-8-类的生命周期2连接阶段 19:58 基础-9-类的生命周期3初始化阶段 26:27 基础-10-类加载器的分类 13:56 基础-11-启动类加载器 13:36 基础-12-扩展和应用程序类加载器 16:26 基础-13-双亲委派机制 18:43 基础-14-打破类的双亲委派机制-自定义类加载器 25:16 基础-15-打破双亲委派机制2-线程上下文类加载器 20:17 基础-16-打破双亲委派机制3-osgi和类的热部署 11:53 基础-17-JDK9之后的类加载器 09:05 基础-18-运行时数据区-程序计数器 15:42 基础-19--局部变量表 19:20 基础-20--操作数栈和帧数据 12:08 基础-21--内存溢出 15:28 基础-22-堆内存 25:56 基础-23-方法区的实现 16:25 基础-24-方法区-字符串常量池 20:40 基础-25-直接内存 12:39 基础-26-自动垃圾回收 11:32 基础-27-方法区的回收 11:32 基础-28-引用计数法 15:41 基础-29-可达性分析法 20:25 基础-30-软引用 24:40 基础-31-弱虚终结器引用 12:08 基础-32-垃圾回收算法的评价标准 13:31 基础-33-垃圾回收算法1 10:05 基础-34-垃圾回收算法-分代GC 20:19 基础-35-垃圾回收器1 15:54 基础-36-垃圾回收器2 11:44 基础-37-垃圾回收器3 15:51 基础-38-g1垃圾回收器 26:23 实战-1-内存泄漏和内存溢出 21:25 实战-2-解决内存泄漏-监控-top命令 12:16 实战-3-解决内存泄漏-监控-visualvm 12:50 实战-4-解决内存泄漏-监控-arthas tunnel 15:18 实战-5-解决内存泄漏-监控-prometheus-grafana 17:53 实战-6-解决内存泄漏-堆内存状况对比 08:39 实战-7-解决内存泄漏-内存泄漏产生的几大原因 16:01 实战-8-内存泄漏产生的原因2 13:30 实战-9-内存泄漏产生的原因3 10:43 实战-10-内存泄漏产生的原因4 10:04 实战-11-内存泄漏产生原因2-并发请求问题 17:30 实战-12-导出堆内存快照并使用MAT分析 08:38 实战-13-MAT内存泄漏检测原理 17:23 实战-14-服务器导出内存快照和MAT使用小技巧 13:31 实战-15-实战1-查询大数据量导致的内存溢出 26:24 实战-16-实战2-mybatis导致的内存溢出 10:34 实战-17-实战3-k8s容器环境导出大文件内存溢出 26:13 实战-18-系统不处理业务时也占用大量的内存 14:13 实战-19-文章审核接口的内存问题 18:28 实战-20-btrace和arthas在线定位问题 20:15 实战-21-GC调优的核心目标 11:23 实战-22-GC调优的常用工具 12:05 实战-23-GC调优的常见工具2 14:25 实战-24-常见的GC模式 13:38 实战-25-基础JVM参数的设置 28:31 实战-26-垃圾回收器的选择 18:04 实战-27-垃圾回收参数调优 07:56 实战-28-实战-GC调优和内存调优 30:43 实战-29-性能问题的现象和解决思路 10:49 实战-30-定位进程CPU占用率高的问题 18:52 实战-31-接口响应时间很长问题的定位 14:44 实战-32-火焰图定位接口响应时间长的问题 12:03 实战-33-死锁问题的检测 14:37 实战-34-基准测试框架JMH的使用 28:24 实战-35-实战-性能调优 26:36 高级-01-GraalVM介绍 12:13 高级-02-GraalVM的两种运行模式 15:43 高级-03-使用SpringBoot3构建GraalVM应用 15:08 高级-04-将GraalVM应用部署到函数计算 25:13 高级-05-将GraalVM应用部署到Serverless 09:14 高级-06-参数优化和故障诊断 22:31 高级-07-垃圾回收器的技术演进 13:09 高级-08-ShenandoahGC 22:50 高级-09-ZGC 14:35 高级-10-实战案例-内存不足时的垃圾回收测试 09:47 高级-11-JavaAgent技术 12:16 高级-12-JavaAgent环境搭建 15:24 高级-13-查看内存的使用情况 18:48 高级-14-生成内存快照 13:47 高级-15-获取类加载器的信息 16:26 高级-16-打印类的源码 18:00 高级-17-使用ASM增强方法 29:45 高级-18-使用ByteBuddy打印方法执行的参数和耗时 21:55 高级-19-APM系统和数据采集 24:30 原理-01-栈上的数据存储 15:05 原理-02-boolean在栈上的存储方式 22:48 原理-03-对象在堆上的存储1 17:27 原理-04-对象在堆上的存储2 25:14 原理-05-方法调用的原理1-静态绑定 19:26 原理-06-方法调用的原理2-动态绑定 15:25 原理-07-异常捕获的原理 12:00 原理-08-JIT即时编译器 14:49 原理-09-JIT即时编译器优化手段1-方法内联 16:49 原理-10-JIT即时编译器优化手段2-逃逸分析 09:03 原理-11-g1垃圾回收器原理-年轻代回收 27:57 原理-12-g1垃圾回收器原理-混合回收 17:24 原理-13-ZGC原理 26:27 原理-14-ShenandoahGC原理 09:39 面试-01-什么是JVM 16:38 面试-02-字节码文件的组成 15:02 面试-03-什么是运行时数据区 20:09 面试-04-哪些区域会出现内存溢出 11:56 面试-05-JDK6-8内存区域上的不同 14:36 面试-06-类的生命周期 17:17 面试-07-什么是类加载器 17:05 面试-08-什么是双亲委派机制 12:15 面试-09-如何打破双亲委派机制 18:10 面试-10-tomcat的自定义类加载器 31:18 面试-11-如何判断堆上的对象有没有被引用 10:05 面试-12-JVM中都有哪些引用类型 16:58 面试-13-theadlocal中为什么要使用弱引用 12:16 面试-14-有哪些垃圾回收算法 24:54 面试-15-有哪些常用的垃圾回收器 18:55 面试-16-如何解决内存泄漏问题 23:52 面试-17-常见的JVM参数 11:11 这是目前我学习的视频集合,要不要全看,或者少了什么,有哪些重要内容需要进行学习汇总或刷题或通过小实例验证
最新发布
10-02
<think>我们正在为一位计算机专业研一学生设计JVM学习方案,该学生研究方向是边缘计算安全(差分隐私、隐私路径等),有408和软件工程基础,目前正在学习JVM。需要评估是否需要全看JVM视频集,补充缺失内容,并提供学习汇总、刷题和实例验证建议。 分析需求: 1. 判断视频全集必要性:基于研究生背景和边缘计算安全方向,不需要全看基础视频,应侧重与安全、资源受限环境相关的JVM特性。 2. 补充缺失内容:边缘设备特有的JVM问题(内存管理、轻量级GC、安全机制)。 3. 学习汇总:结构化知识框架,突出重点。 4. 刷题建议:结合边缘安全场景的实战题目。 5. 小实例验证:通过代码实验加深理解。 参考信息: [^1]: 强调现代程序需兼顾灵活性和安全性。 [^2]: 提到JVM监控工具(如JConsole、VisualVM)对分析GC性能的重要性。 [^3]: 警示微小的不一致会导致严重问题(类比JVM调优需谨慎)。 解决方案: 一、视频学习策略(不全看) - 跳过:基础内存结构、类加载流程等已掌握内容。 - 重点观看: 1. 堆外内存管理(DirectByteBuffer与网络安全缓冲区) 2. 适用于嵌入式设备的GC算法(ZGC/Shenandoah低延迟特性) 3. 字节码验证与安全沙箱(关联边缘设备防恶意代码) 4. JNI安全实践(预防本地代码漏洞) 二、缺失内容补充(边缘计算关联点) - 内存安全:垃圾回收停顿对实时性影响(边缘设备需<10ms停顿) - 轻量化:GraalVM Native Image构建无JVM运行时 - 可信执行:Intel SGX Enclave与JVM的集成 - 资源监控:Linux cgroups限制JVM内存/CPU 三、学习汇总(核心模块) ``` 1. 内存模型进阶 - 堆外内存:ByteBuffer.allocateDirect VS malloc - 内存屏障:VarHandle保证边缘设备数据一致性 2. 垃圾回收调优 - ZGC着色指针技术(适应边缘设备异构内存) - 最大停顿时间预测:`-XX:MaxGCPauseMillis`实战 3. 安全机制 - 类加载隔离:自定义类加载器实现隐私计算引擎隔离 - 字节码加密:Transformer保护边缘节点代码 4. 原生交互 - JNI临界区:GetPrimitiveArrayCritical优化数据传输 - 安全退出:确保本地代码释放资源 ``` 四、刷题建议 - LeetCode题目:不需要传统算法题,改成JVM场景题: 1. 手写安全内存分配器(防止堆外内存泄漏) 2. 模拟ZGC并发处理(并发标记算法实现) - 大厂面试题改造: - 如何诊断边缘设备Full GC?→ 添加资源限制条件(仅512MB RAM) 五、小实例验证 ```java // 边缘设备GC停顿模拟 public class GCPauseSimulator { static final int _1MB = 1024 * 1024; public static void main(String[] args) { // 创建短生命周期对象模拟传感器数据 new Thread(() -> { while (true) { byte[] sensorData = new byte[2 * _1MB]; // 诱发Young GC Thread.sleep(10); } }).start(); // 监控线程(边缘设备需低延迟) new Thread(() -> { long lastTime = System.nanoTime(); while (true) { long now = System.nanoTime(); if (now - lastTime > 20_000_000) { // 20ms停顿警报 System.err.println("GC pause detected: " + (now - lastTime)/1000000 + "ms"); } lastTime = now; } }).start(); } } ``` 运行参数:`-XX:+UseZGC -Xmx256m -XX:+UnlockDiagnosticVMOptions -XX:+PrintGC` 六、监控工具实践(参考引用[^2]) - JConsole:观察堆外内存(Direct Memory)波动 - VisualVM:分析GC日志中停顿时间分布 - 添加安全监控:`-Djava.security.debug=access`跟踪权限检查 相关问题: 1. 如何在512MB内存的边缘设备配置ZGC参数? 2. 自定义类加载器如何防止差分隐私算法被篡改? 3. 边缘设备部署时,如何验证JVM运行时完整性? 4. JNI代码导致的内存泄漏如何诊断? </think>### 针对边缘计算安全方向的JVM学习优化方案 #### 一、视频学习策略(不必全看) 1. **可跳过的基础内容** - 类加载流程、内存区域划分等基础概念(408已覆盖) - GC基础算法(标记清除/复制算法等) *理由:你已具备扎实的计算机基础,重复学习效率低* 2. **必须重点学习的内容** - 堆外内存管理(`DirectByteBuffer`) ```java // 边缘设备内存敏感场景示例 ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024); // 绕过堆内存GC ``` - 低延迟GC原理(**ZGC/Shenandoah**) - 关键参数:`-XX:MaxGCPauseMillis=10`(边缘设备要求<20ms停顿) - 安全沙箱机制 - `SecurityManager`在隐私计算中的应用 - 字节码验证流程(结合差分隐私算法保护) - JNI本地调用安全 - 预防本地代码的内存泄漏攻击 #### 二、缺失关键内容补充(边缘场景特需) | **知识点** | **边缘计算关联性** | **学习资源** | |----------------------|-----------------------------------|----------------------------------| | **GraalVM Native** | 构建无JVM的轻量级安全容器 | [GraalVM官方文档](https://www.graalvm.org/) | | **内存屏障硬件实现** | NUMA架构下边缘节点数据一致性 | 《深入理解计算机系统》第6章 | | **TEE集成** | Intel SGX Enclave隐私计算保护 | [OpenEnclave SDK](https://openenclave.io/) | | **eBPF监控** | 内核级JVM行为审计(安全框架基础) | 《BPF Performance Tools》第11章 | #### 三、学习汇总与优先级建议 ```mermaid graph TD A[JVM核心] --> B[内存模型] A --> C[GC机制] A --> D[执行引擎] B --> B1(堆外内存管理) B --> B2(内存屏障) C --> C1(ZGC/Shenandoah) C --> C2(GC调优实战) D --> D1(字节码验证) D --> D2(JNI安全) style B1 stroke:#f66,stroke-width:2px style C1 stroke:#f66,stroke-width:2px style D2 stroke:#f66,stroke-width:2px ``` #### 四、刷题与实例验证方案 1. **刷题建议(LeetCode改造)** - 传统题:`Java内存泄漏排查` → **改造为** *"在512MB内存的边缘设备上,优化DirectByteBuffer缓存策略"* - 参考[^2]的GC监控方法,增加**资源约束条件**: ```bash # 限制容器资源 docker run -it --cpus=1 --memory=512m openjdk:17 ``` 2. **小实例设计** **边缘设备安全内存分配验证** ```java public class EdgeMemoryValidator { // 模拟边缘设备内存压力 static final int MAX_DIRECT_MEM = 100 * 1024 * 1024; // 100MB public static void main(String[] args) { List<ByteBuffer> buffers = new ArrayList<>(); try { while (true) { buffers.add(ByteBuffer.allocateDirect(2 * 1024 * 1024)); // 每次2MB System.out.println("已分配: " + (buffers.size() * 2) + "MB"); Thread.sleep(100); } } catch (OutOfMemoryError e) { System.err.println("堆外内存溢出! 最大分配: " + (buffers.size() * 2) + "MB"); } catch (InterruptedException ignored) {} } } ``` **运行参数**: `-XX:MaxDirectMemorySize=100m -Xmx50m` **观测点**: - 使用`jcmd <PID> VM.native_memory`监控堆外内存 - 通过[^2]提到的JConsole观察GC行为 #### 五、安全场景验证建议 1. **差分隐私保护实验** - 在JNI层实现拉普拉斯噪声注入: ```c // JNI 代码片段 JNIEXPORT jdouble JNICALL Java_PrivacyEngine_addNoise(JNIEnv *env, jobject obj, jdouble value) { double noise = laplace_noise(0.0, 1.0); // ϵ=1.0的拉普拉斯噪声 return value + noise; } ``` 2. **安全监控实践** - 部署**Prometheus+JMX Exporter**: ```yaml # prometheus.yml 配置片段 - job_name: 'edge_jvm' static_configs: - targets: ['edge-device-ip:9091'] # 边缘设备暴露的JMX端口 ``` --- ### 相关问题 1. 如何在资源受限的边缘设备实现JVM安全热升级? 2. ZGC的`-XX:SoftMaxHeapSize`参数对边缘计算有何特殊价值? 3. 如何通过JVM沙箱防止差分隐私算法被恶意篡改? 4. 在可信执行环境(TEE)中部署JVM需要考虑哪些安全因素? 5. 如何利用eBPF跟踪JVM堆外内存泄漏? > **关键提醒**:边缘计算场景下,JVM学习需重点关注**内存精确控制**、**确定式延迟**和**可信执行**三要素。建议结合[OpenJDK Panama项目](https://openjdk.org/projects/panama/)探索硬件原生交互,这将直接支撑你的隐私路径研究[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值