java JVM核心机制

最新推荐文章于 2020-05-20 14:20:07 发布
最新推荐文章于 2020-05-20 14:20:07 发布
阅读量265 收藏 1
点赞数
分类专栏： java 文章标签： classloader jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15797229/article/details/54092674
版权

类加载全过程

1.编译： 源码经过编译器编译，形成字节码文件(.class)
2. 加载：类加载器（ClassLoader）加载字节码到内存中
3. 链接：将java类的二进制代码合并到JVM运行的状态之中
验证：确保加载的类信息符合JVM规范，没有安全方面的问题
准备：正式为类变量（static变量）分配内存并设置默认值，这些内存都在方法区（堆）中分配
解析：虚拟机常量池中的符号引用替换为直接引用的过程
4. 初始化：初始化阶段执行类构造器（Clinit）方法，类构造器方法是编译器自动收集所有类变量的赋值动作和静态语句块（static块）中的语句合并产生的。当初始化一个类的时候，如果发现其父类还没有被初始化，则先初始化其父类

/**
 * 测试类变量和静态块加载
 * @author L J
 */
public class StaticDemo {
    public static void main(String[] args) throws Exception {
        //类的主动引用(一定会初始化类)
        //1、用new关键字创建对象
        //new A();
        //2、调用类的静态成员
        //System.out.println(A.width);
        //3、对类进行反射调用
        //Class.forName("com.belief.jvm.A");

        //类的被动引用(不会初始化类)
        //1、调用类的常量
        //System.out.println(A.MAX);
        //2、通过数组定义类引用，不会触发此类的初始化
        //A[] a = new A[1];
        //3、访问一个静态域时，只有真正声明这个域的类才会被初始化
        System.out.println(B.width); //类A被初始化
    }

    static {
        System.out.println("静态初始化StaticDemo");
    }
}

class B extends A {
    static {
        System.out.println("静态初始化B");
    }
}

class A extends A_Father {
    public static int width = 100;
    public static final int MAX = 200;

    static {
        System.out.println("静态初始化类A");
        width = 300;
    }

    public A() {
        System.out.println("创建A类的对象");
    }
}

class A_Father {
    static {
        System.out.println("静态初始化A_Father");
    }
}

类加载器

类加载器的层次结构：
类加载器

/**
 * 了解类加载器的层次结构
 * @author L J
 */
public class ClassLoaderDemo {
    public static void main(String[] args) {
        //获取AppClassLoader
        System.out.println(ClassLoader.getSystemClassLoader());
        //获取ExtClassLoader
        System.out.println(ClassLoader.getSystemClassLoader().getParent());
        //java获取不了bootstrap class loader,返回null
        System.out.println(ClassLoader.getSystemClassLoader().getParent().getParent());

        System.out.println(System.getProperty("java.class.path"));
    }
}

双亲委托机制：

  • 类加载采用双亲委托机制（只要有父加载器，就交给父加载器先加载，父加载器不能加载，才自己加载）
  • 为了保证java核心库的类型安全，这种机制保证不会出现用户自定义java.lang.Object类的情况

自定义类加载器

/**
 * 文件系统类加载器
 * @author L J
 */
public class FileSystemClassLoader extends ClassLoader{
    //要加载类的根目录
    private String rootDir;

    public FileSystemClassLoader(String rootDir) {
        this.rootDir = rootDir;
    }

    /**
     * 重写父类的findClass方法
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class<?> c = findLoadedClass(name);

        //先查询是否已经加载过此类，如果已经加载，直接返回；反之加载新的类
        if(c != null) {
            return c;
        }else{//加载新的类
            ClassLoader parent = this.getParent();
            try {
                c = parent.loadClass(name);
            } catch (Exception e) {
                //e.printStackTrace();
            }  //委托给父类加载
            if(c != null) {
                return c;
            }else{//父类没有加载，自己加载
                byte[] classData = getClassData(name); 
                if(classData == null) {
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name, classData, 0, classData.length);
                }
            }
        }
        return c;
    }

    /**
     * 获取要加载类的字节数组
     * @param className 类名
     * @return 要加载类的字节数组
     */
    private byte[] getClassData(String className) {
        //拼接路径
        String path = rootDir + "/" + className.replace(".", "/") + ".class";
        //输入流
        InputStream is = null;
        //输出流
        ByteArrayOutputStream baos = null;
        try {
            is = new FileInputStream(path);
            baos = new ByteArrayOutputStream();

            byte[] buf = new byte[1024];
            int len = 0;
            //文件读取
            while((len = is.read(buf)) != -1) {
                baos.write(buf, 0, len);
            }
            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类：

/**
 * 测试自定义的FileSystemClassLoader类
 * @author L J
 */
public class FileSystemClassLoaderTest {
    public static void main(String[] args) throws Exception {
        FileSystemClassLoader loader = new FileSystemClassLoader("F:/DB");
        FileSystemClassLoader loader2 = new FileSystemClassLoader("F:/DB");
        Class<?> c = loader.findClass("Hello");
        Class<?> c1 = loader.findClass("Hello");
        Class<?> c2 = loader2.findClass("Hello");
        Class<?> c3 = loader.findClass("java.lang.String");

        //同一个类，被不同的类加载器加载，JVM认为是两个不同的类
        System.out.println(c == c1); //true
        System.out.println(c == c2); //false

        //FileSystemClassLoader加载
        System.out.println(c.getClassLoader()); 
        //由bootstrap class loader加载，返回null
        System.out.println(c3.getClassLoader());
    } 
}
/**
 * 网络类加载器
 * @author L J
 */
public class NetClassLoader extends ClassLoader{
    //要加载类的根目录
    private String rootURL;

    public NetClassLoader(String rootURL) {
        this.rootURL = rootURL;
    }

    /**
     * 重写父类的findClass方法
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class<?> c = findLoadedClass(name);

        //先查询是否已经加载过此类，如果已经加载，直接返回；反之加载新的类
        if(c != null) {
            return c;
        }else{//加载新的类
            ClassLoader parent = this.getParent();
            try {
                c = parent.loadClass(name);
            } catch (Exception e) {
                //e.printStackTrace();
            }  //委托给父类加载
            if(c != null) {
                return c;
            }else{//父类没有加载，自己加载
                byte[] classData = getClassData(name); 
                if(classData == null) {
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name, classData, 0, classData.length);
                }
            }
        }
        return c;
    }

    /**
     * 获取要加载类的字节数组
     * @param className 类名
     * @return 要加载类的字节数组
     */
    private byte[] getClassData(String className) {
        //拼接路径
        String path = rootURL + "/" + className.replace(".", "/") + ".class";
        //输入流
        InputStream is = null;
        //输出流
        ByteArrayOutputStream baos = null;
        try {
            URL url = new URL(path);
            is = url.openStream();
            baos = new ByteArrayOutputStream();

            byte[] buf = new byte[1024];
            int len = 0;
            //文件读取
            while((len = is.read(buf)) != -1) {
                baos.write(buf, 0, len);
            }
            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

解密类加载器：

/**
 * 加密(取反)工具类
 * @author L J
 */
@SuppressWarnings("all")
public class EncryptUtil {
    /**
     * 加密文件
     * @param src //源文件
     * @param dest //目标文件
     */
    public static void encrypt(File src, File dest) {
        //文件输入流
        FileInputStream fis = null;
        //文件输出流
        FileOutputStream fos = null;

        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dest);

            int temp = -1;
            while((temp = fis.read()) != -1) {
                fos.write(temp^0xff);  //取反操作
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try { 

                //关闭输出流
                if(fos != null) {
                    fos.close();
                }

                //关闭输入流
                if(fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
/**
 * 解密类加载器
 * @author L J
 */
public class DecryptClassLoader extends ClassLoader {
    //要加载类的根目录
    private String rootDir;

    public DecryptClassLoader(String rootDir) {
        this.rootDir = rootDir;
    }

    /**
     * 重写父类的findClass方法
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class<?> c = findLoadedClass(name);

        //先查询是否已经加载过此类，如果已经加载，直接返回；反之加载新的类
        if(c != null) {
            return c;
        }else{//加载新的类
            ClassLoader parent = this.getParent();
            try {
                c = parent.loadClass(name);
            } catch (Exception e) {
                //e.printStackTrace();
            }  //委托给父类加载
            if(c != null) {
                return c;
            }else{//父类没有加载，自己加载
                byte[] classData = getClassData(name); 
                if(classData == null) {
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name, classData, 0, classData.length);
                }
            }
        }
        return c;
    }

    /**
     * 获取要加载类的字节数组
     * @param className 类名
     * @return 要加载类的字节数组
     */
    private byte[] getClassData(String className) {
        //拼接路径
        String path = rootDir + "/" + className.replace(".", "/") + ".class";
        //输入流
        InputStream is = null;
        //输出流
        ByteArrayOutputStream baos = null;
        try {
            is = new FileInputStream(path);
            baos = new ByteArrayOutputStream();

            int temp = -1;
            while((temp = is.read()) != -1) {
                baos.write(temp^0xff); //取反操作
            }

            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally{
            try {
                if(is != null) {
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
/**
 * 测试加密解密工具类
 * @author L J
 */
public class EncryptDecryptTest {
    public static void main(String[] args) throws Exception {
        //加密
        EncryptUtil.encrypt(new File("F:/DB/Hello.class"), new File("F:/DB/temp/Hello.class"));
        //解密并加载类
        DecryptClassLoader loader = new DecryptClassLoader("F:/DB/temp");
        Class<?> c = loader.loadClass("Hello");
        System.out.println(c);
    }
}
kd_myway
关注
专栏目录
深入理解java反射机制
欸奥维
07-24 3万+
一，java的核心机制java有两种核心机制:java虚拟机(JavaVirtual Machine)与垃圾收集机制(Garbage collection)： Java虚拟机：是运行所有Java程序的抽象计算机，是Java语言的运行环境，在其上面运行Java代码编译后的字节码程序，java虚拟机实现了平台无关性。 Java垃圾回收（Garbage Collection）：自动释放不用对象
Java JVM虚拟机运行机制
08-30
Java JVM虚拟机运行机制是Java程序执行的核心，它允许Java代码在任何支持Java的平台上运行，无需重新编译。JVM作为一个规范，可以被实现为软件或者硬件的一部分，它的设计目的是提供一个平台无关的环境来运行Java...
JVM核心机制
lightpeak的博客
10-24 210
JVM核心机制 类加载过程 JVM 把 class 文件加载到内存，并对数据进行校验，解析和初始化，最终形成 JVM 可以直接使用的 JAVA 类型的过程。 将Java类的二进制代码合并到JVM运行状态之中的过程 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。   准备：正式为类变量 static 变量分配内存并设置类变量初始值的阶段，这些内存都将在方法区中进行分...
jvm核心机制
渣渣瑞
11-30 150
加载——&gt;验证——&gt;准备——&gt;解析——&gt;初始化——&gt;使用——&gt;卸载 加载：将class文件字节码加载到内存中，并将这些静态数据转换成方法区中运行时的数据结构，并在堆中生成一个java.lang.Class对象，作为方法区类数据访问的入口 链接： 验证——&gt;准备——&gt;解析        验证：确保加载的类信息符合jvm规范         准备...
JVM核心知识体系
a1298871304的博客
04-03 176
JVM核心知识体系 1.问题 1、如何理解类文件结构布局？ 2、如何应用类加载器的工作原理进行将应用辗转腾挪？ 3、热部署与热替换有何区别，如何隔离类冲突？ 4、JVM如何管理内存，有何内存淘汰机制？ 5、JVM执行引擎的工作机制是什么？ 6、JVM调优应该遵循什么原则，使用什么工具？ 7、JPDA架构是什么，如何应用代码热替换？ 8、JVM字节码增强技...
java JVM原理与常识知识点
08-26
Java JVM（Java Virtual Machine，Java虚拟机）是Java语言的核心和基础，它是一种虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。JVM是一个虚拟处理器，位于Java编译器和操作系统平台...
Java JVMJava JVMJava JVM
05-30
Java虚拟机（JVM）是Java开发语言的核心组成部分，它为...总结，理解JVM的工作原理、内存管理和并发机制对于优化Java应用程序的性能至关重要。开发者应熟练掌握JVM的各个组件，以便在遇到性能问题时能快速定位并解决。
jvm瓶颈定位 java jvm 学习
03-09
Java虚拟机（JVM）是Java开发中的核心组成部分，它负责执行字节码，管理内存，以及优化程序性能。在Java应用的运行过程中，如果出现性能问题，JVM瓶颈定位就显得至关重要。本文将深入探讨如何理解和解决Java JVM的...
Java jvm虚拟机.zip
11-08
Java JVM（Java Virtual Machine）虚拟机是Java编程语言的核心组成部分，它是Java平台的基石，使得Java程序具有跨平台的能力。JVM是一种抽象的计算机，它执行字节码，提供了运行Java程序所需的环境。理解JVM的工作...
JVM核心机制，类加载全过程
权威
12-06 734
1.类加载机制    -JVM把class文件加载到内存，并对数据进行校验、解析和初始化，最终形成JVM可以直接使用的java类的全过程。                                            -加载      ·将class文件的字节码内存加载到内存当中，并将这些静态数据换成方法区中的运行时数据结构，在堆中生成一个 一个代表这个类的java.lang
学习笔记——JAVA JVM的核心机制
thewaiting的博客
06-08 265
目的：对java类加载的过程深入了解反射 热部署 提高程序的灵活性 动态性加载->链接验证 准备 解析->初始化->使用->卸载package study;public class Text { public static void main(String[] args) { A a = new A(); System.out.println(A.a);
java核心机制之JVM
itlwc
06-13 1951
核心机制之JVM Java虚拟机可以理解成一个以字节码为机器指令的CPU 对于不同的运行平台，有不同的虚拟机 Java虚拟机机制屏蔽了底层运行平台的差别，能够很好的实现跨平台
JVM核心机制_类加载全过程JAVA218-219
好好学习天天向上
04-07 663
一、S02E218_01JVM核心机制_类加载全过程、JVM内存分析、反射机制核心原理、常量池理解二、S02E219_01JVM核心机制_类加载全过程、初始化时机、类的主动引用和被动引用、静态初始化块执行顺序问题
JVM核心机制_类加载全过程
MINGDE_SKILL的博客
06-09 132
深入类加载器： 同一个类，被不通过的类加载器加载，JVM认为也是不同的类。 Tomcat服务器的类加载机制： OSGI原理：
JVM核心机制引言
尚拙的博客
03-01 188
任何一个刚开始学习Java的人都不会忘记能够成功运行hello world的高兴吧，当我们下载好eclipse，好不容易配置变量，然后打开eclipse，在书上抄了这段代码，或者从网上粘贴来，点击运行之后，能够在控制台显示 “hello world”,那种高兴，简直能上天啊。最近自己一直忙的项目已经告一段落，剩下后期优化和测试，抽空将尚学堂落下的课程看看，上周写了一些关于jdbc的相关知识，这...
深入JVM内核---JVM内存模型
weixin_30451709的博客
05-31 92
在上一篇博客中讲GC算法的时候提到了一些关于JVM内存模型.JVM中用heap堆来存储运行时的数据,所有类实例和数组由堆分配内存,JVM启动时创建堆(heap memory),在堆以外的内存叫非堆(non-heap memory) 1.堆(Heap space) 在JVM的堆内存空间中,从大的层面划分,可以分为新生代(Young)和老年代空间(Old).其中Young空间又...
深入JVM内核（二）——JVM运行机制
平凡之路无尽路的博客
07-13 2286
由于之前看的容易忘记，因此特记录下来，以便学习总结与更好理解，该系列博文也是第一次记录，所有有好多不完善之处请见谅与留言指出，如果有幸大家看到该博文，希望报以参考目的看浏览，如有错误之处，谢谢大家指出与留言。 一、目录 JVM启动流程 JVM基本结构 内存模型 编译和解释运行的概念 二、JVM启动流程 jvm启动的时候一定是由java命令，或者javaw命令；java启动命令会跟一个...
JVM核心点
u014525726的博客
05-20 567
1.jvm内存模型 线程私有区： （1）程序计数器 当同时进行的线程数超过CPU数或其内核数时，就要通过时间片轮询分派CPU的时间资源，不免发生线 程切换。这时，每个线程就需要一个属于自己的计数器来记录下一条要运行的指令。如果执行的是JAVA 方法，计数器记录正在执行的java字节码地址，如果执行的是native方法，则计数器为空。 （2）虚拟机栈 线程私有的，与线程在同一时间创建。管理JAVA方法执行的内存模型。每个方法执行时都会创建一个桢 栈来存储方法的的变量表、操作数栈、动态链接方法、返回值、返回地
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值