深入理解JVM—类加载 part2

最新推荐文章于 2024-01-29 09:07:49 发布
最新推荐文章于 2024-01-29 09:07:49 发布
阅读量290 收藏
点赞数
分类专栏： JVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zsjlovesm521/article/details/103036533
版权

Demo11

package com.optimize.learnJVM.classloader;

 

public class MyTest11 {

public static void main(String[] args) {

System.out.println(Child3.a);

Child3.doSomeThing();

}

}

 

class Parent3 {

static int a = 3;

 

static {

System.out.println("Parent3 static block");

}

 

static void doSomeThing() {

System.out.println("do something");

}

}

 

class Child3 extends Parent3 {

static {

System.out.println("Child3 static block");

}

}

 

 

//输出

//Parent3 static block

//3

//do something

 

 

//解释:没有使用到Child的任何数据，没有对其产生一个主动使用。

//总结:通过子类的名称，调用父类的静态变量和静态方法（谁拥有就是主动使用谁），本质上都是对父类的主动使用，而非子类。

Demo12

package com.optimize.learnJVM.classloader;

 

public class MyTest12 {

public static void main(String[] args) throws Exception {

ClassLoader loader = ClassLoader.getSystemClassLoader();

Class<?> clazz = loader.loadClass("com.optimize.learnJVM.classloader.CL");

System.out.println(clazz);

System.out.println("------------");

clazz = Class.forName("com.optimize.learnJVM.classloader.CL");

System.out.println(clazz);

}

}

 

class CL{

static {

System.out.println("Class CL ");

}

}

 

 

//输出

//class com.optimize.learnJVM.classloader.CL

//------------

//Class CL

//class com.optimize.learnJVM.classloader.CL

 

//调用ClassLoader类的loadClass方法加载一个类， 并不是对类的主动使用，不会导致类的初始化

Demo13

package com.optimize.learnJVM.classloader;

 

public class MyTest13 {

public static void main(String[] args) throws Exception {

ClassLoader loader = ClassLoader.getSystemClassLoader();

System.out.println(loader);

System.out.println("-----------");

while (loader!=null){

loader = loader.getParent();

System.out.println(loader);

}

 

}

}

 

//输出

//sun.misc.Launcher$AppClassLoader@18b4aac2

//-----------

//sun.misc.Launcher$ExtClassLoader@5a07e868

//null

 

 

 

 

获得当前类的ClassLoader：clazz.getClassLoader();

获得当前线程上下文的ClassLoader：Thread.currentThread().getContextClassLoader()

获得系统的ClassLoader：ClassLoader.getSystemClassLoader()

获得调用者的ClassLoader：DriverManager.getCallerClassLoader()

Demo14

package com.optimize.learnJVM.classloader;

 

import java.io.IOException;

import java.net.URL;

import java.util.Enumeration;

 

public class MyTest14 {

public static void main(String[] args) throws IOException {

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

System.out.println(classLoader);

String resourceName = "com/optimize/learnJVM/classloader/MyTest13.class";

 

Enumeration<URL> urls = classLoader.getResources(resourceName);

while (urls.hasMoreElements()){

URL url = urls.nextElement();

System.out.println(url);

}

}

}

 

 

//输出

//sun.misc.Launcher$AppClassLoader@18b4aac2

//file:/Users/shijiazhang/AndroidStudioProjects/androidperformance/app/build/intermediates/classes/debug/com/optimize/learnJVM/classloader/MyTest13.class

 

//资源在磁盘上的全路径

Demo15

package com.optimize.learnJVM.classloader;

 

public class MyTest15 {

public static void main(String[] args) {

String[] strings = new String[2];

System.out.println(strings.getClass().getClassLoader());

 

System.out.println("-------------");

 

MyTest15[] myTest15s = new MyTest15[2];

System.out.println(myTest15s.getClass().getClassLoader());

 

System.out.println("-------------");

 

int[] ints = new int[2];

System.out.println(ints.getClass().getClassLoader());

}

}

 

//输出

//null 表示启动类加载器

//-------------

//sun.misc.Launcher$AppClassLoader@18b4aac2

//-------------

//null 表示没有类加载器的 if the element type is a primitive type,then the array class has no class loader。

 

 

//解释

//Class objects for array classes are not created by class loaders,

//but are created automatically as required by the Java runtime.

//The class loader for an array class, as returned by Class.getClassLoader() is the same as

//the class loader for its element type; if the element type is a primitive type,

//then the array class has no class loader.

Demo16-1

package com.optimize.learnJVM.classloader;

 

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

 

public class MyTest16 extends ClassLoader {

private String classLoaderName;

 

private final String fileExtension = ".class";

 

public MyTest16(String classLoaderName) {

super();//将系统类加载器当做该类加载器的父加载器

this.classLoaderName = classLoaderName;

}

 

public MyTest16(ClassLoader parent, String classLoaderName) {

super(parent);//显式指定加载器的父加载器

this.classLoaderName = classLoaderName;

}

 

@Override

protected Class<?> findClass(String className) throws ClassNotFoundException {

System.out.println("findClass invoked :" + className);

System.out.println("class loader name:" + this.classLoaderName);

byte[] data = this.loadClassData(className);

return defineClass(className, data, 0, data.length);

}

 

private byte[] loadClassData(String name) {

InputStream is = null;

byte[] data = null;

ByteArrayOutputStream baos = null;

 

 

try {

this.classLoaderName = this.classLoaderName.replace(".", "/");

 

is = new FileInputStream(new File(name + this.fileExtension));

baos = new ByteArrayOutputStream();

 

int ch;

while (-1 != (ch = is.read())) {

baos.write(ch);

}

 

data = baos.toByteArray();

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

is.close();

baos.close();

} catch (IOException e) {

e.printStackTrace();

}

}

return data;

}

 

public static void test(ClassLoader classLoader) throws Exception {

Class<?> clazz = classLoader.loadClass("com.optimize.learnJVM.classloader.MyTest1");

Object object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

}

 

 

public static void main(String[] args) throws Exception {

MyTest16 loader1 = new MyTest16("loader1");

test(loader1);

}

}

 

 

//输出

//com.optimize.learnJVM.classloader.MyTest1@5a07e868

//sun.misc.Launcher$AppClassLoader@18b4aac2

//并不是我们的MyTest16类加载器加载的,那么问题出现在哪里呢？

 

 

// MyTest16 loader1 = new MyTest16("loader1");我们使用的这种方式，使用的是MyTest16父类加载作为parent的，MyTest16的父加载器是系统类加载器，能在classpath中找到相关的文件就直接加载了。

Demo16-2

package com.optimize.learnJVM.classloader;

 

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

 

public class MyTest16 extends ClassLoader {

private String classLoaderName;

 

private String path;//磁盘加载路径

 

private final String fileExtension = ".class";

 

public MyTest16(String classLoaderName) {

super();//将系统类加载器当做该类加载器的父加载器

this.classLoaderName = classLoaderName;

}

 

public MyTest16(ClassLoader parent, String classLoaderName) {

super(parent);//显式指定加载器的父加载器

this.classLoaderName = classLoaderName;

}

 

public void setPath(String path) {

this.path = path;

}

 

@Override

public String toString() {

return "MyTest16{" +

"classLoaderName='" + classLoaderName + '\'' +

'}';

}

 

 

@Override

protected Class<?> findClass(String className) throws ClassNotFoundException {

System.out.println("findClass invoked :" + className);

System.out.println("class loader name:" + this.classLoaderName);

byte[] data = this.loadClassData(className);

return defineClass(className, data, 0, data.length);

}

 

private byte[] loadClassData(String className) {

InputStream is = null;

byte[] data = null;

ByteArrayOutputStream baos = null;

 

className = className.replace('.', '/');

 

try {

this.classLoaderName = this.classLoaderName.replace(".", "/");

 

is = new FileInputStream(new File(this.path + className + this.fileExtension));

baos = new ByteArrayOutputStream();

 

int ch;

while (-1 != (ch = is.read())) {

baos.write(ch);

}

 

data = baos.toByteArray();

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

is.close();

baos.close();

} catch (IOException e) {

e.printStackTrace();

}

}

return data;

}

 

 

public static void main(String[] args) throws Exception {

MyTest16 loader1 = new MyTest16("loader1");

//通过路径去加载

// loader1.setPath("/Users/shijiazhang/AndroidStudioProjects/androidperformance/app/build/intermediates/classes/debug/");

 

loader1.setPath("/Users/shijiazhang/Desktop/");

Class<?> clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz.hashCode());

Object object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

 

System.out.println();

 

MyTest16 loader2 = new MyTest16(loader1,"loader2");

loader2.setPath("/Users/shijiazhang/Desktop/");

Class<?> clazz2 = loader2.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz2.hashCode());

Object object2 = clazz2.newInstance();

System.out.println(object2);

System.out.println(object2.getClass().getClassLoader());

 

System.out.println();

 

MyTest16 loader3 = new MyTest16(loader2,"loader3");

loader3.setPath("/Users/shijiazhang/Desktop/");

Class<?> clazz3 = loader3.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz3.hashCode());

Object object3 = clazz3.newInstance();

System.out.println(object3);

System.out.println(object3.getClass().getClassLoader());

}

}

 

 

//输出

//com.optimize.learnJVM.classloader.MyTest1@5a07e868

//sun.misc.Launcher$AppClassLoader@18b4aac2

//并不是我们的MyTest16类加载器加载的,那么问题出现在哪里呢？

 

 

// MyTest16 loader1 = new MyTest16("loader1");我们使用的这种方式，使用的是MyTest16父类加载作为parent的。

 

// mkdir -p ~/Desktop/com/optimize/learnJVM/classloader

// cp /Users/shijiazhang/AndroidStudioProjects/androidperformance/app/build/intermediates/classes/debug/com/optimize/learnJVM/classloader/MyTest1.class ~/Desktop/com/optimize/learnJVM/classloader

 

//删除文件中的MyTest1在运行

 

//输出

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@3fee733d

//MyTest16{classLoaderName='loader1'}

 

//解释：

//将工程中的MyTest1删除，并去加载桌面中的MyTest1。

//当加载的时候系统类加载器找不到工程中的MyTest1，之后转移给自定义的MyTest16去加载

 

 

//将MyTest1添加回来

//输出

//class : 1510467688

//com.optimize.learnJVM.classloader.MyTest1@76ed5528

//sun.misc.Launcher$AppClassLoader@18b4aac2

 

 

//添加loader2

//输出

//class : 1510467688

//com.optimize.learnJVM.classloader.MyTest1@76ed5528

//sun.misc.Launcher$AppClassLoader@18b4aac2

//class : 1510467688

//com.optimize.learnJVM.classloader.MyTest1@2c7b84de

//sun.misc.Launcher$AppClassLoader@18b4aac2

//一个类只会加载一次（在同一个命名空间内）

 

//删除MyTest1

//输出

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@3fee733d

//MyTest16{classLoaderName='loader1'}

//

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader2

//class : 918221580

//com.optimize.learnJVM.classloader.MyTest1@7a81197d

//MyTest16{classLoaderName='loader2'}

//由于命名空间不同导致的加载2次相同的类

 

// 设置loader2的父加载器为loader1

// MyTest16 loader2 = new MyTest16(loader1,"loader2");

//输出

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@3fee733d

//MyTest16{classLoaderName='loader1'}

//

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@5acf9800

//MyTest16{classLoaderName='loader1'}

 

 

//设置loader3

// MyTest16 loader3 = new MyTest16("loader3");

//输出

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@3fee733d

//MyTest16{classLoaderName='loader1'}

//

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@5acf9800

//MyTest16{classLoaderName='loader1'}

//

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader3

//class : 2055281021

//com.optimize.learnJVM.classloader.MyTest1@5ca881b5

//MyTest16{classLoaderName='loader3'}

 

 

// MyTest16 loader3 = new MyTest16(loader2,"loader3");

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@3fee733d

//MyTest16{classLoaderName='loader1'}

//

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@5acf9800

//MyTest16{classLoaderName='loader1'}

//

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@4617c264

//MyTest16{classLoaderName='loader1'}

Demo16-3

package com.optimize.learnJVM.classloader;

 

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

 

public class MyTest16 extends ClassLoader {

private String classLoaderName;

 

private String path;//磁盘加载路径

 

private final String fileExtension = ".class";

 

public MyTest16(String classLoaderName) {

super();//将系统类加载器当做该类加载器的父加载器

this.classLoaderName = classLoaderName;

}

 

public MyTest16(ClassLoader parent, String classLoaderName) {

super(parent);//显式指定加载器的父加载器

this.classLoaderName = classLoaderName;

}

 

public void setPath(String path) {

this.path = path;

}

 

@Override

public String toString() {

return "MyTest16{" +

"classLoaderName='" + classLoaderName + '\'' +

'}';

}

 

 

@Override

protected Class<?> findClass(String className) throws ClassNotFoundException {

System.out.println("findClass invoked :" + className);

System.out.println("class loader name:" + this.classLoaderName);

byte[] data = this.loadClassData(className);

return defineClass(className, data, 0, data.length);

}

 

private byte[] loadClassData(String className) {

InputStream is = null;

byte[] data = null;

ByteArrayOutputStream baos = null;

 

className = className.replace('.', '/');

 

try {

this.classLoaderName = this.classLoaderName.replace(".", "/");

 

is = new FileInputStream(new File(this.path + className + this.fileExtension));

baos = new ByteArrayOutputStream();

 

int ch;

while (-1 != (ch = is.read())) {

baos.write(ch);

}

 

data = baos.toByteArray();

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

is.close();

baos.close();

} catch (IOException e) {

e.printStackTrace();

}

}

return data;

}

 

 

public static void main(String[] args) throws Exception {

MyTest16 loader1 = new MyTest16("loader1");

//通过路径去加载

// loader1.setPath("/Users/shijiazhang/AndroidStudioProjects/androidperformance/app/build/intermediates/classes/debug/");

 

loader1.setPath("/Users/shijiazhang/Desktop/");

Class<?> clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz.hashCode());

Object object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

 

 

System.out.println();

 

loader1 = new MyTest16("loader1");

loader1.setPath("/Users/shijiazhang/Desktop/");

clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz.hashCode());

object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

 

 

}

}

 

//输出

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@3fee733d

//MyTest16{classLoaderName='loader1'}

//

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 918221580

//com.optimize.learnJVM.classloader.MyTest1@7a81197d

//MyTest16{classLoaderName='loader1'}

 

//两次加载的确实不一样,但不一定是被卸载了

 

 

 

 

 

public static void main(String[] args) throws Exception {

MyTest16 loader1 = new MyTest16("loader1");

//通过路径去加载

// loader1.setPath("/Users/shijiazhang/AndroidStudioProjects/androidperformance/app/build/intermediates/classes/debug/");

 

loader1.setPath("/Users/shijiazhang/Desktop/");

Class<?> clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz.hashCode());

Object object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

 

 

System.out.println();

loader1 = null;

clazz = null;

object = null;

System.gc();

 

loader1 = new MyTest16("loader1");

loader1.setPath("/Users/shijiazhang/Desktop/");

clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz.hashCode());

object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

 

}

 

 

//添加-XX:+TraceClassUnloading

//输出

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 746292446

//com.optimize.learnJVM.classloader.MyTest1@3fee733d

//MyTest16{classLoaderName='loader1'}

//

//[Unloading class com.optimize.learnJVM.classloader.MyTest1 0x00000007c0061028]

//findClass invoked :com.optimize.learnJVM.classloader.MyTest1

//class loader name:loader1

//class : 918221580

//com.optimize.learnJVM.classloader.MyTest1@7a81197d

//MyTest16{classLoaderName='loader1'}

 

 

 

public static void main(String[] args) throws Exception {

MyTest16 loader1 = new MyTest16("loader1");

//通过路径去加载

// loader1.setPath("/Users/shijiazhang/AndroidStudioProjects/androidperformance/app/build/intermediates/classes/debug/");

 

loader1.setPath("/Users/shijiazhang/Desktop/");

Class<?> clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz.hashCode());

Object object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

 

 

System.out.println();

 

loader1 = null;

clazz = null;

object = null;

 

Thread.sleep(200000);

 

System.gc();

 

 

loader1 = new MyTest16("loader1");

loader1.setPath("/Users/shijiazhang/Desktop/");

clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MyTest1");

System.out.println("class : " + clazz.hashCode());

object = clazz.newInstance();

System.out.println(object);

System.out.println(object.getClass().getClassLoader());

 

}

 

 

//线程睡眠20秒

//终端打开jvisualvm

//选择启动的进程

//选择监视 查看类的已装入的总数和已卸载的总数变化

//如果我们添加看MyTest1，使的其又系统类加载器加载的话，就不会出现类卸载的情况。

 

Demo17-1

package com.optimize.learnJVM.classloader;

 

public class MyCat {

public MyCat() {

System.out.println("MyCat is loaded by:" + this.getClass().getClassLoader());

}

}

 

 

 

package com.optimize.learnJVM.classloader;

 

public class MySample {

public MySample() {

System.out.println("MySample is loaded by:" + this.getClass().getClassLoader());

new MyCat();//创建MyCat，使两个类产生关联

}

}

 

 

 

package com.optimize.learnJVM.classloader;

 

public class MyTest17 {

public static void main(String[] args) throws Exception {

MyTest16 loader1 = new MyTest16("loader1");

Class<?> clazz = loader1.loadClass("com.optimize.learnJVM.classloader.MySample");

System.out.println("class : " + clazz.hashCode());

//如果注释掉该行，那么并不会实例化MySample对象，即MySample构造方法不会被调用

//因此不会实例化MyCat对象，即没有对MyCat进行主动使用个，这里就不会加载Mycat Class

Object object = clazz.newInstance();

 

}

}

 

 

//输出

//class : 1995265320

//MySample is loaded by:sun.misc.Launcher$AppClassLoader@18b4aac2

//MyCat is loaded by:sun.misc.Launcher$AppClassLoader@18b4aac2

//

//注释掉Object object = clazz.newInstance();

//只是加载，但是没有生成实例，因此没有执行到构造方法。其实不一定加载mycat

//可以通过-XX:+TraceClassLoading,用于追踪类的加载信息并打印出来

 

 

//解释

//类加载器并不需要等到某个类被“首次主动使用”时再加载它

//●JVM规范允许类加载器在预料某个类将要被使用时就预先加载它，如果在预先加载的过程中遇到了.class文件缺失或存在错误，类加载器必须在程序首次主动使用该类时才报告错误(LinkageError错误)

//●如果这个类一直没有被程序主动使用，那么类加载器就不会报告错误

Demo17-2

package com.optimize.learnJVM.classloader;

 

/**

* 关于命名空间重要说明

* 1.子加载器所加载的类能够访问父加载器所加载的类

* 2.父加载器所加载的类无法访问子加载器所加载的类

*/

public class MyTest17_1 {

public static void main(String[] args) throws Exception {

MyTest16 loader1 = new MyTest16("loader1");

loader1.setPath("/Users/shijiazhang/Desktop/");

Class<?> clazz = loader1.loadClass("com.shengsiyuan.jvm.classloader.MySample");

System.out.println("class : " + clazz.hashCode());

//如果注释掉该行，那么并不会实例化MySample对象，即MySample构造方法不会被调用

//因此不会实例化MyCat对象，即没有对MyCat进行主动使用个，这里就不会加载Mycat Class

Object object = clazz.newInstance();

 

}

}

 

 

//classes文件中删除MySample和MyCat

//findClass invoked :com.optimize.learnJVM.classloader.MySample

//class loader name:loader1

//class : 1072591677

//MySample is loaded by:MyTest16{classLoaderName='loader1'}

//findClass invoked :com.optimize.learnJVM.classloader.MyCat //Mycat在MySample里也是由MyTest16进行加载

//class loader name:loader1

//MyCat is loaded by:MyTest16{classLoaderName='loader1'}

//

//删除class文件中的Mycat

//class : 1627674070

//MySample is loaded by:sun.misc.Launcher$AppClassLoader@18b4aac2

//Exception in thread "main" java.lang.NoClassDefFoundError: com/shengsiyuan/jvm/classloader/MyCat

// at com.shengsiyuan.jvm.classloader.MySample.<init>(MySample.java:6)

// at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)

// at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)

// at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)

// at java.lang.reflect.Constructor.newInstance(Constructor.java:423)

// at java.lang.Class.newInstance(Class.java:442)

// at com.shengsiyuan.jvm.classloader.MyTest17_1.main(MyTest17_1.java:11)

//Caused by: java.lang.ClassNotFoundException: com.shengsiyuan.jvm.classloader.MyCat

// at java.net.URLClassLoader.findClass(URLClassLoader.java:382)

// at java.lang.ClassLoader.loadClass(ClassLoader.java:424)

// at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)

// at java.lang.ClassLoader.loadClass(ClassLoader.java:357)

// ... 7 more

//

//Process finished with exit code 1

//

//删除class文件中的MySample

//findClass invoked :com.shengsiyuan.jvm.classloader.MySample

//class loader name:loader1

//class : 1625635731

//MySample is loaded by:MyTest16{classLoaderName='loader1'}

//MyCat is loaded by:sun.misc.Launcher$AppClassLoader@18b4aac2//MyTest16委托父加载去加载，由系统类加载器加载成功

//

//

//在MyCat中添加了对MySample的使用，再删除class文件中的MySample

//public class MyCat {

// public MyCat() {

// System.out.println("MyCat is loaded by:" + this.getClass().getClassLoader());

// System.out.println("from MyCat : "+MySample.class);

// }

//}

//findClass invoked :com.shengsiyuan.jvm.classloader.MySample

//class loader name:loader1

//class : 1625635731

//MySample is loaded by:MyTest16{classLoaderName='loader1'}

//MyCat is loaded by:sun.misc.Launcher$AppClassLoader@18b4aac2

//Exception in thread "main" java.lang.NoClassDefFoundError: com/shengsiyuan/jvm/classloader/MySample

// at com.shengsiyuan.jvm.classloader.MyCat.<init>(MyCat.java:6)

// at com.shengsiyuan.jvm.classloader.MySample.<init>(MySample.java:6)

// at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)

// at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)

// at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)

// at java.lang.reflect.Constructor.newInstance(Constructor.java:423)

// at java.lang.Class.newInstance(Class.java:442)

// at com.shengsiyuan.jvm.classloader.MyTest17_1.main(MyTest17_1.java:11)

//Caused by: java.lang.ClassNotFoundException: com.shengsiyuan.jvm.classloader.MySample

// at java.net.URLClassLoader.findClass(URLClassLoader.java:382)

// at java.lang.ClassLoader.loadClass(ClassLoader.java:424)

// at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)

// at java.lang.ClassLoader.loadClass(ClassLoader.java:357)

// ... 8 more

//

//解释：命名空间

//每个类加载器都有自己的命名空间，命名空间由该加载器及所有父加载器所加载的类组成。

// 在同一个命名空间中，不会出现类的完整名字(包括类的包名)相同的两个类

// 在不同的命名空间中，有可能会出现类的完整名字(包括类的包名)相同的两个类。

// 父加载加载的类看不到子加载加载的类（AppClassLoader看不到MyTest16加载的MySample）

 

 

//子的命名空间访问父的命名空间的MyCat

//在MySample也引用MyCat

//public class MySample {

// public MySample() {

// System.out.println("MySample is loaded by:" + this.getClass().getClassLoader());

// new MyCat();//创建MyCat，使两个类产生关联

//

// System.out.println("from MyCat : "+MyCat.class);

// }

//}

//public class MyCat {

// public MyCat() {

// System.out.println("MyCat is loaded by:" + this.getClass().getClassLoader());

System.out.println("from MyCat : "+MySample.class);

// }

//}

//输出

//findClass invoked :com.shengsiyuan.jvm.classloader.MySample

//class loader name:loader1

//class : 1625635731

//MySample is loaded by:MyTest16{classLoaderName='loader1'}

//MyCat is loaded by:sun.misc.Launcher$AppClassLoader@18b4aac2

//from MyCat : class com.shengsiyuan.jvm.classloader.MyCat

好书速览-深入理解JVM-Part1
m0_51663233的博客
06-28 814
计算机好书精读第一期-Part1-JVM虚拟机
深入理解HotSpot JVM 基本原理
最新发布
RickyIT的专栏
04-21 941
它保存所有被JVM加载的类和接口的运行时常量池，成员变量以及方法的信息，静态变量以及方法的字节码。每条线程还有自己的工作内存（Working Memory，可与前面讲的处理器高速缓存类比），线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量。禁止指令重排序优化，普通的变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。
十四、类的命名空间与卸载详解及jvisualvm使用
lifeline张的博客
05-10 175
1、类的卸载 当一个类被加载、连接、初始化后，他的生命周期就开始了。当代表该类的Class对象不再被引用时，即不可触及时，Class对象就会结束生命周期，该类在方法区的数据也会被卸载，从而结束类的生命周期。 一个类何时结束生命周期，取决于代表他的Class对象何时结束生命周期。 由java虚拟机自带的类加载器所加载的类，在虚拟机的生命周期中，始终不会被卸载。java虚拟机自带的类加载器包括根类加载器、扩展类加载器和系统类加载器。java虚拟机本身会始终引用这些类加载器，而这些类加载器则会始终引用他们所加载的
java 统计程序项目下面所有Java类的个数和有效代码行数的递归算法
u014181326的专栏
12-01 4084
思路很简单，通过for 循环遍历文件，遇到java文件，则统计代码行数，遇到目录则继续递归遍历。 代码奉上，注释很清楚了，这里就不多说了。
JAVA类加载与卸载
YmovomY的博客
01-29 635
JAVA类加载与卸载
JVMTI 实现统计Java类对象实例个数
weixin_38526093的博客
02-13 1402
上述回调函数的第三个参数class_tag可以用来进行对Class进行分组,相同的class_tag对应相同的类对象,从而在FollowReferences的回调函数中完成Class对象实例个数的累加和所占用空间大小的计算。Java没有提供很直接优雅的方式让我们能够去轻易的去获取类对象的实例的数量,也许是出于性能的考虑,也许是这种事情本身没有显示出多大的价值,毕竟不那么常用。当Class参数值为空的时候,返回虚拟机中已装载的类的统计信息集合,当Class参数值不为空的时候,返回该Class的统计信息。
Tomcat之Jconsole监控
11-13 290
JConsole的图形用户界面是一个符合Java管理扩展（JMX）规范的监测工具，JConsole使用Java虚拟机（Java VM），提供在Java平台上运行的应用程序的性能和资源消耗的信息。在Java平台，标准版（Java SE平台）6，JConsole的已经更新到目前的外观，类似于Windows和GNOME桌面（其他平台，将目前标准的Java图形的外观和感觉），在这个文件中提出的屏幕截图是从...
深入理解Java虚拟机（第2版）
《深入理解Java虚拟机》(Inside the Java Virtual Machine) 是一本经典的JVM技术书籍，由Bill Venners所著。该书旨在提供对Java平台及其内部运行机制的深度剖析，帮助读者深入了解Java的核心架构和工作原理。全书...
Java - JVM: 读书笔记 Chapter 05 The Java Virtual Machine ( Part I Basic )
07-26
2. **类加载机制**：JVM的类加载过程包括加载、验证、准备、解析和初始化五个阶段。加载阶段找到类的二进制数据，验证确保数据的正确性，准备阶段为静态变量分配内存并初始化为默认值，解析将符号引用转换为直接引用...
揭示Java类加载内幕(code)
03-01
Java类加载机制是Java运行时环境中的核心组成部分，它负责将类的字节码加载到JVM中并进行实例化。这个过程对于理解和优化Java应用性能至关重要。在本篇文章中，我们将深入探讨Java类加载器的工作原理，以及其在代码...
jvisualvm工具使用
weixin_34297704的博客
03-10 647
VisualVM 是Netbeans的profile子项目，已在JDK6.0 update 7 中自带(java启动时不需要特定参数，监控工具在bin/jvisualvm.exe)。   https://visualvm.dev.java.net/   一、介绍 VisualVM，能够监控线程，内存情况，查看方法的CPU时间和内存中的对 象，已被GC的对象，反向查看分配的堆栈(如100个Stri...
java类加载
weixin_30443895的博客
11-21 125
类加载时要调用初始化代码，何为初始化代码？其实就是类文件中写的static代码块，如下： 1 public class Car { 2 // 静态代码块，就是初始化代码 3 static { 4 System.out.println("买一辆车"); 5 } 6 7 public void drive() { 8...
《java性能优化权威指南》---- 第4章：JVM性能监控
jushisi的博客
11-30 442
定义 一、垃圾收集 二、JIT编译器 三、类加载 四、Java应用监控
低调不失奢华 “Java性能调优六大工具”之VisualVM多合一工具
公众号：该用户快成仙了
11-03 746
VisualVM多合一工具 VisualVM是一个功能强大的多合一故障诊断和性能监控的可视化工具。它集成了多种性能统计工具的功能，使用VisualVM可以代替jstat、jmap、jhat、jstack甚至是JConsole。在JDK6update7以后，VisualVM便作为JDK的一部分被发布出来，它完全免费。 VisualVM也可以作为独立的软件进行安装，读者可以在http://visualvm.java.net上下载并安装VisualVM的最新版本。 在本节的介绍中，笔者所使用的VisualV
ViewUtil工具类
zsjlovesm521的博客
10-18 872
ViewUtil工具类 设置当前是否需要隐藏 设置View是否可用 扩大View的触摸和点击响应范围,最大不超过其父View范围 /****************************************** * 类描述:操作View的工具类 * * @author: yangshaoning ******************************************...
深入理解JVM—类加载 part3
zsjlovesm521的博客
11-12 1682
Demo18 package com.shengsiyuan.jvm.classloader; public class MyTest18 { public static void main(String[] args) throws Exception { MyTest16 loader1 = new MyTest16("load...
torch的model加载完怎么看_看完这篇后，别再说你不懂JVM类加载机制了~
weixin_39708708的博客
01-08 177
精彩推荐一百期Java面试题汇总SpringBoot内容聚合IntelliJ IDEA内容聚合Mybatis内容聚合Class类文件的结构任何一个Class文件都对应着唯一一个类或接口的定义信息，但反过来说，类或接口并不一定都得定义在文件里(类和接口也可以用反射的方式通过类加载器直接生成)Class文件时一组以8位字节为基础单位的二进制流，各个数据都严格按照顺序紧凑排列在Class文件中...
【Java_jvm】Window下查看本地JVM类的实例数量及占用内存
chenghan_yang的博客
10-22 4776
1. 导出dump文件 1.1 获取PID(两种方式) 可以使用任务管理器获取 也可以使用jconsole间接获取 在jdk的bin 目录下找到jconsole.exe 执行即可 如果看不到本地进程、文件权限可能存在问题 解决： 先通过本地java代码运行： System.out.println(System.getProperties()); 查看属性java.io.tmpdir=C:\Users%USER%\AppData\Local\Temp 注: 此处%USER%为变量代表操作系统用户
JVisualVM 简介
热门推荐
gw的博客
04-21 2万+
VisualVM 是Netbeans的profile子项目，已在JDK6.0 update 7 中自带，能够监控线程，内存情况，查看方法的CPU时间和内存中的对 象，已被GC的对象，反向查看分配的堆栈(如100个String对象分别由哪几个对象分配出来的)。在JDK_HOME/bin(默认是C:\Program Files\Java\jdk1.6.0_13\bin)目录下面，有一个jvisualv...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值