OQL 入门

最新推荐文章于 2025-03-15 08:00:00 发布
最新推荐文章于 2025-03-15 08:00:00 发布
阅读量1.1k 收藏 14
点赞数 11
分类专栏： Java 文章标签： java oql 内存分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjc133/article/details/145058167
版权

分析 Java 内存问题时，dump 堆内存，然后导入到 MAT 中进行分析，是每个 Java 程序员手到擒来的事情，但实际上大家的使用浮于表面，很多好用的功能都没用过。
最近做了几次内存快照的分析，发现 OQL 是个好东西，蛮有意思的。以前大多直接使用 MAT 中的各种功能，但比较少去关注 OQL 这块。

Eclipse的Wiki在24年就要准备关闭了。趁着还能访问，赶紧把文档整理一波。

https://wiki.eclipse.org/MemoryAnalyzer/OQL#GROUP_BY

概述

Object Query Language，即OQL，是一种SQL风格的查询语言，用于对堆转储文件进行分析。

示例：

<font style="color:rgb(76, 77, 78);">SELECT * FROM java.lang.String</font>

列出所有String对象 as tree

<font style="color:rgb(76, 77, 78);">SELECT s as String,s.value as "characters" FROM java.lang.String s</font>

列出所有String对象 as table

<font style="color:rgb(76, 77, 78);">SELECT s as String,s.value as "characters", inbounds(s),inbounds(s).@length FROM java.lang.String s</font>

inbounds函数返回一个数组，包含所有直接引用字符串对象 s 的其他对象。

String                          |characters                                 |inbounds(s)| inbounds(s).@length
--------------------------------------------------------------------------------------------------------------
java.lang.String [id=0x22e58820]|char[] [id=0x22e60f50;length=16;size=48]   |[I@620f7a39|                   1
java.lang.String [id=0x22e59150]|char[] [id=0x22e62ff0;length=6;size=24]    |[I@1f7b8d59|                   1
java.lang.String [id=0x22e5b560]|char[] [id=0x22e6b730;length=537;size=1088]|[I@28551755|                   1
--------------------------------------------------------------------------------------------------------------

在OQL中有两类对象:IObject(快照中的Java对象)和OQL处理生成的常规Java对象。

java.lang.String [id=0x22e58820] 就是一个代表了String快照的 「I 实例」

char[] [id=0x22e60f50;length=16;size=48]是一个代表了字符数组快照的「I 数组」

[I@620f7a39则是由OQL生成的常规Java List 对象，其中包含了多个表示 I 实例的int类型变量

OQL加强版：MAT/Calcite

MAT/Calcite是一个插件，为MAT提供增强能力。比如在OQL中不支持count、group by、sum等等非常常用的功能。但MAT/Calcite支持。MAT/Calcite使用SQL语句，与OQL略有不同。

插件地址：https://github.com/vlsi/mat-calcite-plugin

功能点OQLCalcite
基础语法SELECT s FROM java.lang.String sSELECT s.this FROM “java.lang.String” s
内置函数SELECT toString(s), classof(s),
s.@objectAddress, s.@usedHeapSize, s.@retainedHeapSize
FROM java.lang.String s		SELECT toString(s.this),getType(s.this),
getAddress(s.this),shallowSize(s.this),retainedSize(s.this)
FROM “java.lang.String” s
更多函数SELECT h, h[0:-1].size(), h.table,
h.table.@length, h.modCount, h.getField(“modCount”)
FROM java.util.HashMap h		SELECT h.this,getSize(h.this),h.this[‘table’],
LENGTH(h.this[‘table’]), h.this[‘modCount’], getField(h.this,‘modCount’)
FROM “java.util.HashMap” h
多行注释/* multi-line comment *//* multi-line comment */
单行注释// comment– comment
JOIN原生不支持，但可通过一定的逻辑模拟支持
LIMIT and OFFSET原生不支持，但可通过一定的逻辑模拟支持
ORDER BY语句本身不支持，但可通过点击查询结果的表头来排序支持
GROUP BY原生不支持，但可通过一定的逻辑模拟。也可以通过Java Basics > Group by Value进行查询，此外，如果行的背后是一个对象(from子句返回一个对象列表)，那么Group by菜单栏选项允许Group by classloader和Group by package。支持
COUNT原生不支持，但可通过一定的逻辑模拟支持
MAX,MIN语句本身不支持，但可通过点击查询结果的表头来排序后，手动复制第一个值支持
AVG,SUM不支持支持

Calcite提供高级SQL功能，如JOIN (INNER JOIN、LEFT JOIN、RIGHT JOIN、FULL JOIN)、CROSS JOIN、GROUP BY、ORDER BY。其中的一部分如果花点心思，也可以用OQL来模拟。

关于2019年11月的增强

在 Issue 552879 下对 OQL 进行了各种更新和增强：针对子查询、映射、上下文提供者、DISTINCT的OQL增强。这些可从快照构建中获得，用于测试，并且可能会更改。请在bug、论坛或开发邮件列表上发表评论。

SELECT DISTINCT

DISTINCT曾经只对返回对象的查询结果进行操作，而不是一般的select项。

SELECT DISTINCT OBJECTS classof(s) FROM "java.lang\.S.*" s

而现在，DISTINCT也可以作用于选择项。它使用整行作为不同的项。

SELECT DISTINCT classof(s) FROM "java.lang\.S.*" s

子查询

以前，子查询只允许返回一个对象列表

SELECT v, v.@length FROM OBJECTS ( SELECT OBJECTS s.value FROM java.lang.String s ) v

现在，可以返回任意元素

SELECT v,v.s,v.val FROM OBJECTS ( SELECT s,s.value as val FROM java.lang.String s ) v

Row                                                                                |Object                          |Array
--------------------------------------------------------------------------------------------------------------------------------------------------------------
{s=java.lang.String [id=0x26ba8a30], val=char[] [id=0x26ba8a48;length=14;size=40]} |java.lang.String [id=0x26ba8a30]|char[] [id=0x26ba8a48;length=14;size=40]
{s=java.lang.String [id=0x26ba8998], val=char[] [id=0x26ba89b0;length=56;size=128]}|java.lang.String [id=0x26ba8998]|char[] [id=0x26ba89b0;length=56;size=128]
{s=java.lang.String [id=0x26ba8160], val=char[] [id=0x26ba8178;length=56;size=128]}|java.lang.String [id=0x26ba8160]|char[] [id=0x26ba8178;length=56;size=128]
{s=java.lang.String [id=0x26b9d390], val=char[] [id=0x26b9d3a8;length=15;size=48]} |java.lang.String [id=0x26b9d390]|char[] [id=0x26b9d3a8;length=15;size=48]
{s=java.lang.String [id=0x26b9d358], val=char[] [id=0x26b9d370;length=8;size=32]}  |java.lang.String [id=0x26b9d358]|char[] [id=0x26b9d370;length=8;size=32]
--------------------------------------------------------------------------------------------------------------------------------------------------------------

外层查询一行一行的处理子查询的返回结果，使用单个RowMap Map对象表示行，Map 的键值对就是子查询的结果。如果键是标准的标识符，即通常是字母-数字，那么属性处理可以使用v.s而不是v.get("s2")，虽然它仍然可以被使用。

整个子查询仍会返回CustomTableResultSet，一个IResultTable实例。但现在已经被增强为一个List<RowMap>。在OQL中很难对整个结果进行操作，如果它被提供给外部select，那么Iterable的性质意味着它将逐行处理。

SELECT * FROM OBJECTS ( SELECT s, s.value AS val FROM java.lang.String s ) v

[{s=java.lang.String [id=0x26ba8a30], val=char[] [id=0x26ba8a48;length=14;size=40]}, {s=java.lang.String [id=0x26ba8998], val=char[] [id=0x26ba89b0;length=56;size=128]}, {s=java.lang.String [id=0x26ba8160], val=char[] [id=0x26ba8178;length=56;size=128]}, {s=java.lang.String [id=0x26b9d390], val=char[] [id=0x26b9d3a8;length=15;size=48]}, {s=java.lang.String [id=0x26b9d358], val=char[] [id=0x26b9d370;length=8;size=32]}, {s=java.lang.String [id=0x26b9d318], val=char[] [id=0x26b9d330;length=11;size=40]}, {s=java.lang.String [id=0x26b9d2e8], val=char[] [id=0x26b9d300;length=4;size=24]}, {s=java.lang.String [id=0x26b9c758], val=char[] [id=0x26b9c770;length=21;size=56]}, {s=java.lang.String [id=0x26b9c6c8], val=char[] [id=0x26b9c6e0;length=13;size=40]}, {s=java.lang.String [id=0x26b9c690], val=char[] [id=0x26b9c6a8;length=8;size=32]}, ...

将整个表显示为一个列表

LIMIT 和 OFFSET

可通过以下语句模拟：

SELECT eval((SELECT * FROM OBJECTS ( SELECT s, s.value AS val FROM java.lang.String s ) v))[3] FROM OBJECTS 0

其中：

eval((SELECT * FROM OBJECTS ( SELECT s, s.value AS val FROM java.lang.String s  ) v ))[3]
-----------------------------------------------------------------------------------------
{s=java.lang.String [id=0x26b9d390], val=char[] [id=0x26b9d3a8;length=15;size=48]}
-----------------------------------------------------------------------------------------

将整个表作为一个select项，可以模拟SQL的limit和offset。

SELECT z.s FROM OBJECTS ( eval((SELECT s FROM "java.lang.String" s ))[10:29] ) z

上述语句提取了20个条目，跳过了前10个。注意数组切片处理时，起始和结束偏移量都是基于0但包含0的。

当然，如果用Calcite实现就简单的多：

SELECT s.this FROM "java.lang.String" s LIMIT 10 offset 20

object列的上下文菜单

如果有一列是用来表示堆内对象或者堆内对象的数组/列表，则上下文菜单提供了一个选项来处理所选行的列的项目。

SELECT s AS String, s.value AS "Char array", inbounds(s) AS Inbounds FROM java.lang.String s

结果如下：

String                          |Char array                               |Inbounds
--------------------------------------------------------------------------------------
java.lang.String [id=0x26ba8a30]|char[] [id=0x26ba8a48;length=14;size=40] |[I@6ad112de
java.lang.String [id=0x26ba8998]|char[] [id=0x26ba89b0;length=56;size=128]|[I@18a0721b
java.lang.String [id=0x26ba8160]|char[] [id=0x26ba8178;length=56;size=128]|[I@2ae2fa13
--------------------------------------------------------------------------------------

上下文菜单：

SELECT … s

整行——基于底层对象。对应OQL：

SELECT s AS String, s.value AS "Char array", inbounds(s) AS Inbounds FROM OBJECTS 20798,20796,20793 s

String

仅指查询出来的String字段。对应OQL：

SELECT s AS String FROM OBJECTS 20798,20796,20793 s

Char array

仅指查询出来的Char array字段。对应OQL：

SELECT s.value AS "Char array" FROM OBJECTS 20798,20796,20793 s

Inbounds

所有直接引用了该对象的对象。对应OQL：

SELECT inbounds(s) AS Inbounds FROM OBJECTS 20798,20796,20793 s

上下文菜单中有一个Copy > OQL Query选项，可以拷贝出代表查询该行数据的OQL。

将结果表转换为HTML的报告插件现在使用上下文菜单名称来匹配表列，从而将HTML链接放在表中各列的正确位置，而不是总是放在第一列。这也适用于其他查询，因此当在报表中使用system properties查询时，它有键和值的链接。

提出一个问题（Wiki作者提出）：如果一列有一个堆对象，但不是第一列，那么上下文菜单是否应该出现在所有列中。对于保存字符串或数值的非对象列，就会出现上下文菜单。当没有任何查询(除了复制选择)可以做任何事情时，为这些提供上下文菜单是否令人困惑。

Map处理

Map堆对象现在可以通过数组标记访问了，返回Map.Entry对象。以前对该数组访问会返回Map.Entry对象，再通过key和value来访问键值对。但不是所有的Map都有Entry，所以现在系统用getKey()和getValue()来访问键值对。

SELECT h AS map, (SELECT e.getKey() AS key, e.getValue() AS value FROM OBJECTS ${h}[0:-1] e ) AS kv FROM java.util.HashMap h WHERE (h[0:-1].size() > 0)

map                              |kv
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
java.util.HashMap [id=0x22f49970]|[{key=java.lang.String [id=0x22f44658], value=java.lang.String [id=0x22f44670]}, {key=java.lang.String [id=0x22f44688], value=java.lang.String [id=0x22f446a0]}]
java.util.HashMap [id=0x22f49948]|[{key=java.lang.String [id=0x22f44628], value=java.lang.String [id=0x22f44640]}]
java.util.HashMap [id=0x22f49920]|[{key=java.lang.String [id=0x22f445c8], value=java.lang.String [id=0x22f445e0]}, {key=java.lang.String [id=0x22f445f8], value=java.lang.String [id=0x22f44610]}]
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

将Map解析为键值对的列表。

展平

第二列是键值对的列表。如果能进一步处理这些就太好了，自动展平是实现这一目标的一种方法。如果子查询返回一个包含列表或数组值的RowMap，那么自动展平将该RowMap拆分为多个RowMap，每个RowMap对应于列表或数组的一个条目。其他对象只是在RowMap中重复出现。如果有多个长度不同的列表或数组，则列表或数组末尾以外的元素将被替换为null。

这是扁平化的另一个例子——查看父节点的任何子节点是否没有对父节点的反向引用。

SELECT group AS Group, thread AS Thread 
FROM OBJECTS ( SELECT t AS group, t.threads[0:-1] AS thread FROM java.lang.ThreadGroup t  ) 
WHERE ((thread != null) and (thread.group != group))

这将选择所有java.lang.ThreadGroup对象，然后生成包含两列的行，即线程组和子线程列表。然后将其平展为组的行和单个子线程，其中select然后检查非空子线程和不指向线程组的子线程。请注意，在WHERE前省略别名是不必要的——外部select中的group和thread不需要用别名限定。

GROUP BY

可通过以下方式模拟：

SELECT s.sz AS Size, 
(SELECT OBJECTS m FROM java.util.HashMap m WHERE (m[0:-1].size() = s.sz)) AS Maps 
FROM OBJECTS ( SELECT DISTINCT h[0:-1].size() AS sz FROM java.util.HashMap h  ) s
  1. 这首先获取要分组的东西的列表，这里是size列表。
  2. 然后将size作为子选择返回到下一阶段。
  3. 然后，select items子句只选择与当前组值匹配的对象。
  4. 然后，结果被转换为一个对象列表，它以int[]数组的形式出现在列中，然后可以用作上下文菜单。

另一个例子是根据被直接引用的数量分组：

SELECT s.sz AS Size, 
(SELECT OBJECTS m FROM INSTANCEOF java.lang.Object m WHERE (inbounds(m).@length = s.sz)) AS Objects 
FROM OBJECTS ( SELECT DISTINCT inbounds(h).@length AS sz FROM INSTANCEOF java.lang.Object h  ) s

COUNT

可以通过以下方式模拟：

SELECT z.size AS Size, 
z.maps AS Maps, 
z.maps.@length AS "Count", 
z.maps[0:-1].size() AS "Count (another way)" 
FROM OBJECTS ( eval((
  SELECT 
  s.sz AS size, 
  (SELECT OBJECTS m FROM java.util.HashMap m WHERE (m[0:-1].size() = s.sz)) AS maps 
  FROM OBJECTS ( SELECT DISTINCT h[0:-1].size() AS sz FROM java.util.HashMap h  ) s
)) ) z
  1. 首先获取要分组的东西的列表，这里是size列表。
  2. 然后将size作为子查询返回到下一阶段。
  3. 然后，select items子句只选择与当前组值匹配的对象。
  4. 然后，结果被转换为一个对象列表，在列中以int[]数组的形式出现
  5. 然后用eval()包裹select对象，这样外部的select对象就不会把它拉平
  6. 然后，外层select会生成结果，包括size、映射以及两种计算map数组中元素数量的方法，一种是使用@length，另一种是使用size()。

另一个例子：

SELECT z.size AS Size, 
z.objects AS Objects,
z.objects.@length AS "Count", 
z.objects[0:-1].size() AS "Count (another way)" 
FROM OBJECTS ( eval((
  SELECT s.sz AS size, 
  (SELECT OBJECTS m FROM INSTANCEOF java.lang.Object m WHERE (inbounds(m).@length = s.sz)) AS objects 
  FROM OBJECTS ( SELECT DISTINCT inbounds(h).@length AS sz FROM INSTANCEOF java.lang.Object h  ) s
)) ) z

JOIN

除了 UNION 之外，OQL 没有 SQL 风格的连接操作。通过展平可以模拟其中一些操作，但所需的语句也更复杂。

考虑一个场景，基于java.lang.Integer和java.lang.Long都有的 value 字段进行 JOIN 操作

CROSS JOIN

以下 SQL ：

SELECT i.this,i.this['value'] AS "Integer value", l.this,l.this['value'] AS "Long value" 
FROM "java.lang.Integer" i CROSS JOIN "java.lang.Long" l

可以被等价转换为 OQL：

SELECT z.i AS Integer, z.i.value AS "Integer value", z.lv.l AS Long, z.lv.l.value as "Long value" 
FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Long l ) AS lv FROM java.lang.Integer i  ) z

这会选择所有的java.lang.Integer对象，遍历对象，并选择出对应的java.lang.Long对象，然后展平行。同一行中的Integer和Long对象不必值匹配。

LEFT JOIN / LEFT OUTER JOIN

以下 SQL：

SELECT i.this,i.this['value'] AS "Integer value", l.this,l.this['value'] AS "Long value" 
FROM "java.lang.Integer" i LEFT JOIN "java.lang.Long" l ON i.this['value']+0 = l.this['value']+0

可以被等价转换为 OQL：

SELECT z.i AS Integer, z.i.value AS "Integer value", z.lv.l AS Long, z.lv.l.value as "Long value"  
FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Long l WHERE (l.value = i.value)) AS lv FROM java.lang.Integer i  ) z

INNER JOIN

此操作生成左表（对象集）中的每一行，右表（对象集）中有匹配行。结果表不大于左右表中较小的表。

SELECT z.i AS Integer, z.i.value AS "Integer value", z.lv.l AS Long, z.lv.l.value as "Long value" 
FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Long l WHERE (l.value = i.value)) AS lv FROM java.lang.Integer i  ) z 
WHERE (z.lv != null)

这会选择所有的java.lang.Integer对象，遍历 Integer 然后生成一行 Object，以及所有具有相同值的java.lang.LongObject 列表，然后展平并且排除掉没有Long值的行。

SELECT z.iv.i AS Integer, z.iv.i.value AS "Integer value", z.l AS Long, z.l.value as "Long value" 
FROM OBJECTS ( SELECT (SELECT i FROM java.lang.Integer i WHERE (i.value = l.value)) AS iv, l FROM java.lang.Long l  ) z 
WHERE (z.iv != null)

这会选择所有的java.lang.Long对象，遍历 Long 然后生成 Object，以及对应的具有相同值的java.lang.Integer 对象列表，然后展平并且排除掉没有Integer值的行。每一个展平行都包含一个Long值和一个Integer值，两个值符合Where条件WHERE (i.value = l.value)。

以上OQL都等价于SQL：

SELECT i.this,i.this['value'] AS "Integer value", l.this,l.this['value'] AS "Long value" 
FROM "java.lang.Integer" i INNER JOIN "java.lang.Long" l ON i.this['value']+0 = l.this['value']+0

RIGHT JOIN / RIGHT OUTER JOIN

SELECT i.this,i.this['value'] AS "Integer value", l.this,l.this['value'] AS "Long value" 
FROM "java.lang.Integer" i RIGHT JOIN "java.lang.Long" l ON i.this['value']+0 = l.this['value']+0

以上SQL等价于以下OQL：

SELECT z.iv.i AS Integer, z.iv.i.value AS "Integer value", z.l AS Long, z.l.value as "Long value" 
FROM OBJECTS ( SELECT (SELECT i FROM java.lang.Integer i WHERE (i.value = l.value)) AS iv, l FROM java.lang.Long l  ) z

这会查询所有的Long对象，遍历 Long 对象并且生成具有相同值的Integer对象列表，然后展平行。每一个展平行都包含一个Long对象和一个可能存在的相同值的Integer对象，或者是null

FULL OUTER JOIN

此操作为左表（对象集）的每一行和右表（对象集）的每一行生成一行，但当左表的一行与右表的一行具有相同值时，它们将被包括在同一输出行中。结果表至少与左表和右表中较大的表一样大。

SELECT z.i AS Integer, z.i.value AS "Integer value", z.lv.l AS Long, z.lv.l.value as "Long value" 
FROM OBJECTS ( SELECT i, (SELECT l FROM java.lang.Long l WHERE (l.value = i.value)) AS lv FROM java.lang.Integer i  ) z 
UNION (
SELECT z.iv.i AS Integer, z.iv.i.value AS "Integer value", z.l AS Long, z.l.value as "Long value" 
FROM OBJECTS ( SELECT (SELECT i FROM java.lang.Integer i WHERE (i.value = l.value)) AS iv, l FROM java.lang.Long l  ) z 
WHERE (z.iv = null)
)

这会执行LEFT JOIN / LEFT OUTER JOIN 操作，然后将这些行与所有没有相应的java.lang.Long对象的列表结合起来。每一行包含一个Integer对象或Long对象或两者都有。

等价以下SQL：

SELECT i.this,i.this['value'] AS "Integer value", l.this,l.this['value'] AS "Long value" 
FROM "java.lang.Integer" i FULL OUTER JOIN "java.lang.Long" l ON i.this['value']+0 = l.this['value']+0

OQL的编写思路

OQL语法有点绕，又缺失一些SQL的常见功能，再加上平时使用频率不高。编写起来是需要一个不断尝试的过程的。例如，考虑这个问题：

我想找到特定类型的所有不可达的对象。

通常，MAT会丢弃不可达对象，唯一可以看到的是对象图表中的不可达对象占内存的总数。这对于OQL没有用，因此我们需要-keep_unreachable_objects选项。不可达的对象不会被丢弃，而是由一些人为插入的UNREACHABLE_OBJECT垃圾收集根保留。

让我们来看一些例子：

snapshot有一些有趣的方法，包括getGCRoots()

SELECT * FROM OBJECTS ${snapshot}.getGCRoots() r

因为它是一个以get开头的无参数方法，我们可以使用bean属性来访问它。

SELECT * FROM OBJECTS ${snapshot}.@GCRoots r

[21800, 21801, 21802, 21803, 21804, 21805,

返回的这些Integer值是MAT对象的ID。

但这给出了所有的GC根，而我们只想要不可达的GC根。

试试这个方式：

SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(21800) t

[org.eclipse.mat.parser.model.XGCRootInfo@2b963bbc]

它返回XGCRootInfo的列表，遍历一下列表中的元素：

SELECT t FROM OBJECTS ${snapshot}.getGCRootInfo(21800) t

r
-------------------------------------------------
org.eclipse.mat.parser.model.XGCRootInfo@2b963bbc
-------------------------------------------------

通过查 MAT 的 API 文档可以看到它有一个getType()方法，所以：

SELECT t,t.@type FROM OBJECTS ${snapshot}.getGCRootInfo(21800) t

t                                                | t.@type
-----------------------------------------------------------
org.eclipse.mat.parser.model.XGCRootInfo@2b963bbc|       2
-----------------------------------------------------------

而GCRootInfo.Type.UNREACHABLE的值为2048，所以：

SELECT t,t.@type FROM OBJECTS ${snapshot}.getGCRootInfo(21800) t WHERE t.@type = 2048

这不会返回任何内容，因为对象ID 21800是SYSTEM根。但我们可以使用它来从所有GC根中进行选择，如果没有找到UNREACHABLE根，则该子SELECT条款为空。我们可以将选择项简化为 *，因为它并不重要。

SELECT OBJECTS r FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null

Class Name                                          | Shallow Heap | Retained Heap
-----------------------------------------------------------------------------------
int[11] @ 0x22ef4c58 Unreachable                    |           56 |            56
int[9] @ 0x22ed2ad8 Unreachable                     |           48 |            48
int[7] @ 0x22ed2b28 Unreachable                     |           40 |            40
int[17] @ 0x22ed3150 Unreachable                    |           80 |            80
java.lang.ref.SoftReference @ 0x22f52cd8 Unreachable|           32 |           400
-----------------------------------------------------------------------------------

看起来有希望——我们现在有了一个对象列表，里面都是UNREACHABLE GC根。

SELECT AS RETAINED SET r FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null


r
--------------------------------------------------------------------

java.lang.Class [id=0x26970198;name=java.lang.Throwable[]]
java.lang.Class [id=0x26970370;name=java.lang.Error[]]
java.lang.Class [id=0x26970558;name=java.lang.VirtualMachineError[]]
--------------------------------------------------------------------

或许可以将它们视为数，而不是Table。

SELECT AS RETAINED SET * FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null

Class Name                                                        | Shallow Heap | Retained Heap
-------------------------------------------------------------------------------------------------
int[33] @ 0x22e5be20 Unreachable                                  |          144 |           144
int[27] @ 0x22e5bed0 Unreachable                                  |          120 |           120
int[17] @ 0x22e5bf60 Unreachable                                  |           80 |            80
sun.reflect.NativeConstructorAccessorImpl @ 0x22e5c5d8 Unreachable|           24 |           184
sun.reflect.NativeConstructorAccessorImpl @ 0x22e5c5f0 Unreachable|           24 |           184
-------------------------------------------------------------------------------------------------

如果我们对这些类型很感兴趣，那么工具栏右上角的“Show as Histogram”按钮将按类别显示总数。如果我们对子类感兴趣，那么‘ Group by superclass’选项可以做到这一点。

但是，我们可能希望完全通过 OQL 完成这项工作——例如，作为另一个查询的一部分或以批处理模式完成。现在我们只需要选择我们感兴趣的类型的对象。有几种方法。

  1. 我们可以列出我们可能感兴趣的类型的所有对象，并将这些对象保留在retained set 中
  2. 我们可以查看每个保留的对象，看看每个对象是否都在我们感兴趣的对象列表中
  3. 我们可以查看每个保留的对象，找到它的类，然后找到它的类名称，看看类名称是否与我们感兴趣的对象匹配
SELECT * FROM java.util.ArrayList o
SELECT * FROM java.util.ArrayList o WHERE o in
(SELECT AS RETAINED SET * FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null)

-- 或者
SELECT * FROM OBJECTS (SELECT AS RETAINED SET * FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null) u
 WHERE u in (SELECT * FROM java.util.ArrayList o)

-- 或者
SELECT * FROM OBJECTS (SELECT AS RETAINED SET * FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null) u
 WHERE u.@clazz.@name = "java.util.ArrayList"

结果如下：

Class Name                      | Shallow Heap | Retained Heap
---------------------------------------------------------------
java.util.ArrayList @ 0x22efe620|           24 |           320
java.util.ArrayList @ 0x22efe608|           24 |           320
java.util.ArrayList @ 0x22efe5a8|           24 |           320
java.util.ArrayList @ 0x22efcfd8|           24 |           384
java.util.ArrayList @ 0x22efb998|           24 |           320
java.util.ArrayList @ 0x22efb928|           24 |           320
---------------------------------------------------------------

如果我们想查询继承了java.util.AbstractCollection的对象，可以用：

SELECT * FROM INSTANCEOF java.util.AbstractCollection o WHERE o in
(SELECT AS RETAINED SET * FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null)

-- 或者
SELECT * FROM OBJECTS (SELECT AS RETAINED SET * FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null) u
 WHERE u in (SELECT * FROM INSTANCEOF java.util.AbstractCollection o)

-- 或者
SELECT * FROM OBJECTS (SELECT AS RETAINED SET * FROM OBJECTS ${snapshot}.getGCRoots() r
 WHERE (SELECT * FROM OBJECTS ${snapshot}.getGCRootInfo(r) t WHERE t.@type = 2048) != null) u
 WHERE u.@clazz.doesExtend("java.util.AbstractCollection")

返回值如下：

Class Name                      | Shallow Heap | Retained Heap
---------------------------------------------------------------
java.util.ArrayList @ 0x22efb928|           24 |           320
java.util.ArrayList @ 0x22efb998|           24 |           320
java.util.ArrayList @ 0x22efcfd8|           24 |           384
java.util.ArrayList @ 0x22efe5a8|           24 |           320
java.util.ArrayList @ 0x22efe608|           24 |           320
java.util.ArrayList @ 0x22efe620|           24 |           320
java.util.Vector @ 0x22f2b5e8   |           24 |            80
java.util.HashSet @ 0x22f2b600  |           16 |           136
java.util.Vector @ 0x22f2b638   |           24 |            80
---------------------------------------------------------------

提取线程信息

SELECT u.Thread AS Thread, u.Frame.@text AS Frame 
  FROM OBJECTS ( 
    SELECT t AS Thread, ${snapshot}.getThreadStack(t.@objectId).@stackFrames AS Frame 
      FROM java.lang.Thread t  ) u

-- 上面查询中的子查询
SELECT t AS Thread, ${snapshot}.getThreadStack(t.@objectId).@stackFrames AS Frame 
  FROM java.lang.Thread t
-- 提取每个线程和堆栈帧数组。然后，外部选择使用其每个堆栈帧的相同线程引用来初始化该数组

执行结果如下：

Thread                           |Frame
--------------------------------------------------------------------------------------------------------------------------------------------------
java.lang.Thread [id=0x7b6a1e7f0]|at java.lang.Object.wait(J)V (Native Method)
java.lang.Thread [id=0x7b6a1e7f0]|at java.lang.Object.wait(JI)V (Unknown Source)
java.lang.Thread [id=0x7b6a1e7f0]|at com.squareup.okhttp.ConnectionPool.performCleanup()Z (ConnectionPool.java:305)
java.lang.Thread [id=0x7b6a1e7f0]|at com.squareup.okhttp.ConnectionPool.runCleanupUntilPoolIsEmpty()V (ConnectionPool.java:242)
java.lang.Thread [id=0x7b6a1e7f0]|at com.squareup.okhttp.ConnectionPool.access$000(Lcom/squareup/okhttp/ConnectionPool;)V (ConnectionPool.java:54)
java.lang.Thread [id=0x7b6a1e7f0]|at com.squareup.okhttp.ConnectionPool$1.run()V (ConnectionPool.java:97)
--------------------------------------------------------------------------------------------------------------------------------------------------

你甚至可以从每一个帧里提取出Local

SELECT v.Thread as Thread, toString(v.Thread) AS Name, v.Frame AS Frame, ${snapshot}.getObject(v.Objs) AS Local 
      FROM OBJECTS ( 
        SELECT u.Thread AS Thread, u.Frame.@text AS Frame, u.Frame.@localObjectsIds AS Objs 
          FROM OBJECTS ( 
            SELECT t AS Thread, ${snapshot}.getThreadStack(t.@objectId).@stackFrames AS Frame 
              FROM java.lang.Thread t
          ) u
      ) v 
      WHERE (v.Objs != null)

v.Thread                         |Name                 |Frame                                                                                                           |Local
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
java.lang.Thread [id=0x7b6a1e7f0]|OkHttp ConnectionPool|at com.squareup.okhttp.ConnectionPool.performCleanup()Z (ConnectionPool.java:305)                               |java.util.ArrayList [id=0x7bb402eb8]
java.lang.Thread [id=0x7b6a1e7f0]|OkHttp ConnectionPool|at com.squareup.okhttp.ConnectionPool.performCleanup()Z (ConnectionPool.java:305)                               |com.squareup.okhttp.ConnectionPool [id=0x6c556ccb0]
java.lang.Thread [id=0x7b6a1e7f0]|OkHttp ConnectionPool|at com.squareup.okhttp.ConnectionPool.runCleanupUntilPoolIsEmpty()V (ConnectionPool.java:242)                   |com.squareup.okhttp.ConnectionPool [id=0x6c556ccb0]
java.lang.Thread [id=0x7b6a1e7f0]|OkHttp ConnectionPool|at com.squareup.okhttp.ConnectionPool.access$000(Lcom/squareup/okhttp/ConnectionPool;)V (ConnectionPool.java:54)|com.squareup.okhttp.ConnectionPool [id=0x6c556ccb0]
java.lang.Thread [id=0x7b6a1e7f0]|OkHttp ConnectionPool|at com.squareup.okhttp.ConnectionPool$1.run()V (ConnectionPool.java:97)                                         |com.squareup.okhttp.ConnectionPool$1 [id=0x6c556ccd8]
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

展示对象的全部字段

SELECT t.s AS "Object", toHex(t.s.@objectAddress) AS "Object address", t.f.@name AS "Field name", t.f.@value AS "Field value" 
    FROM OBJECTS ( SELECT s, s.@fields AS f FROM "java.util.*" s 
        WHERE (s implements org.eclipse.mat.snapshot.model.IInstance) ) t

结果如下：

Object                          |Object address|Field name     |Field value
--------------------------------|--------------|---------------|-----------
java.util.TreeMap [id=0x3acd178]|0x3acd178     |comparator     |
java.util.TreeMap [id=0x3acd178]|0x3acd178     |root           |0x3c32f60
java.util.TreeMap [id=0x3acd178]|0x3acd178     |size           |2
java.util.TreeMap [id=0x3acd178]|0x3acd178     |modCount       |2
java.util.TreeMap [id=0x3acd178]|0x3acd178     |entrySet       |
java.util.TreeMap [id=0x3acd178]|0x3acd178     |navigableKeySet|
java.util.TreeMap [id=0x3acd178]|0x3acd178     |descendingMap  |
java.util.TreeMap [id=0x3acd178]|0x3acd178     |keySet         |
java.util.TreeMap [id=0x3acd178]|0x3acd178     |values         |
java.util.TreeMap [id=0x3acd1a8]|0x3acd1a8     |comparator     |
java.util.TreeMap [id=0x3acd1a8]|0x3acd1a8     |root           |0x3c32f80
--------------------------------|--------------|---------------|-----------
Java从入门到精通- Java VisualVM 插件介绍
隔壁老瓦的专栏
05-21 3984
官方和第三方插件可以轻松扩展VisualVM功能。使用工具|插件|可用插件可从VisualVM插件中心下载插件。IDE集成插件可在此处获得。 要在离线环境中扩展VisualVM功能，请在“插件中心”页面上获取插件，然后使用“工具” |“工具”。插件|下载以安装它们。 由于VisualVM 2.0中的更改，某些第三方插件可能无法正常工作。请联系他们的供应商并要求更新。 MBeans浏览器 MBeans浏览器插件提供的功能类似于JConsole中的MBeans浏览器...
Python入门基础书单——肯定有你想要的！
Python_Partner的博客
07-18 598
​在Python基础图书中共收录了41本推荐图书，并附上了资源获取的方法。如果推荐的图书对你有帮助，为了更好的学习体验和知识产权的保护，请到正规渠道购买正版书籍。 python学习手册（第4版） https://pan.baidu.com/s/1fBKy1pF3gEIH_XuqrvUSrw 提取码：gbms 流畅的python https://pan.baidu.com/s/1pQgwVKM-tf-hkxY9Mxt6DQ 提取码：gpdj Python语言及其应..
oql4j对象查询语言
奕辰杰的博客
08-21 1279
oql4j 全称 Object Query Language For Java，即java版本的对象查询语言，支持使用编写查询语言快速的搜索出符合条件的对象，简化对象的过滤处理操作。目前支持where条件的过滤。
OQL基本教程（个人笔记）
04-01
SOA 框架 用友U9 笔记。OQL教程基础 个人总结。希望对大家有帮助。 本人积分比较少 貌似黑了 点呵呵！
图解JVM - 24.使用OQL语言查询对象信息
最新发布
Anarkh_Lee的博客
03-15 401
MAT支持一种类似于SQL的查询语言OQL（Object Query Language）。OQL使用类SQL语法，可以在堆中进行对象的查找和筛选。
JVM 对象查询语言（OQL）
热门推荐
潘建南的博客
08-24 2万+
本文主要翻译自JDK 1.8的JVM监控工具jhat中关于OQL的英文帮助说明。 可以在jhat 和 jvisualvm 中进行实践。 OQL（对象查询语言）  OQL是用于查询Java堆的类SQL查询语言。OQL允许过滤/选择从Java堆中获取的信息。虽然HAT已经支持预定义的查询，例如“显示类X的所有实例”，但OQL增加了更多的灵活性。OQL基于JavaScript表达式语言。   O...
OQL
magicwb_bb的专栏
02-14 1553
今天有进行了一些OQL研究OQL Object Query Language ，前面将它与HQL比较了一下，感觉，我们的OQL更有难度，HQL 解析比较简单，只需要将HQL简单地替换成SQL就可以了，将HQL中的对象和属性自动替换成对应的数据库信息就ok了，完全不用解析HQL中各种SQL关键字，因为它们两的关键字都一样，根本不用替换。HQL需要用户了解 各种类对象之间的关系OQL只需要
ORM查询语言（OQL）简介--高级篇：脱胎换骨
weixin_34362991的博客
07-26 301
   相关文章内容索引： ORM查询语言（OQL）简介--概念篇 ORM查询语言（OQL）简介--实例篇 ORM查询语言（OQL）简介--高级篇：脱胎换骨 ORM查询语言（OQL）简介--高级篇（续）：庐山真貌       在写本文之前，一直在想文章的标题应怎么取。在写了《ORM查询语言（OQL）简介--概念篇》、《ORM查询语言（OQL）简介--实例篇》之后，觉得...
od入门教程（标题干嘛要写那么多）
11-10
3. **查询语言**：OD通常有自定义的查询语言，例如OQL（Object Query Language），用于检索和操作对象数据库中的数据。熟悉这些查询语法是至关重要的。 4. **OD的持久化**：理解如何将内存中的对象状态保存到数据库...
db4o对象数据库快速入门教程
此外，你还可以学习到如何利用db4o的特性，如透明持久化、自动激活和查询语言（OQL）等。 db4o的设计目标是让对象持久化变得更加简单，它允许开发者直接存取对象，而无需进行映射或转换到关系模型。这使得开发过程...
OQL应用指南
04-18
OQL是一套面向对象的查询语言，基本上是SQL语句在面向对象中的对应物，它使用对象的类名，属性名等概念表达SQL中原来的表名，列名来表达查询概念，返回一个表格状的数据
OrientDB入门指南：学习、部署与定制
作为一本英文入门教程，作者 Claudio Tesoro 在书中详细介绍了 OrientDB 的核心概念、安装过程、数据模型设计以及如何利用其特性进行开发。 本书的目标读者包括希望涉足 NoSQL 技术的开发者，特别是那些对图形...
ORM查询语言（OQL）简介--概念篇
weixin_34228617的博客
10-06 266
 相关文章内容索引： ORM查询语言（OQL）简介--概念篇 ORM查询语言（OQL）简介--实例篇 ORM查询语言（OQL）简介--高级篇：脱胎换骨 ORM查询语言（OQL）简介--高级篇（续）：庐山真貌   一、ＳＱＬ与ＯＲＭ  　　关系数据库(RDBMS)的查询有SQL（Structured Query Language）结构化查询语言，相比高级程序...
＜JVM下篇：性能监控与调优篇＞补充：使用OQL语言查询对象信息
VectorX's Blog
05-05 691
https://gitee.com/vectorx/NOTE_JVM https://codechina.csdn.net/qq_35925558/NOTE_JVM https://github.com/uxiahnan/NOTE_JVM 文章目录补充：使用OQL语言查询对象信息1. SELECT子句2. FROM子句3. WHERE子句4. 内置对象与方法 补充：使用OQL语言查询对象信息 MAT支持一种类似于SQL的查询语言OQL（Object Query Language）。OQL使用类SQL语法.
OQL资料汇总
03-20 385
visualvm oql查询https://www.cnblogs.com/lmjk/articles/7478154.htmljhat中的OQL（对象查询语言）https://www.cnblogs.com/ceshi2016/p/6070566.html虚拟机学习系列 - 附 - OQL（对象查询语言）http://blog.csdn.net/su1216/article/details/77...
OQL详解
demon7552003的小本本
12-30 2754
OQL是用于查询Java堆的类SQL查询语言。OQL允许过滤/选择从Java堆中获取的信息。虽然HAT已经支持预定义的查询，例如“显示类X的所有实例”，但OQL增加了更多的灵活性。OQL基于JavaScript表达式语言。
2020-11-26
liujiang1233的博客
11-26 146
《深入理解java虚拟机》
ORM查询语言（OQL）简介
萌萌的It人 www.itmmd.com
07-26 1803
在写本文之前，一直在想文章的标题应怎么取。在写了《ORM查询语言（OQL）简介--概念篇》、《ORM查询语言（OQL）简介--实例篇》之后，觉得本篇文章应该是前2篇的延续，但又不是一般的延续，因为今天要写的这篇内容，是基于对框架OQL完全重构之后来写的，所以加上一个副标题：脱胎换骨！   一、OQL之前生 1.1，内容回顾： OQL是我设计用来处理PDF.NET开发框架的ORM查询的，因此
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值