JVM学习-类加载过程(二)

news2024/11/18 17:12:28
Initialization初始化阶段
  • 为类的静态变量赋予正确的初始值
具体描述
  • 类的初始化是类装载的最后一个阶段，如果前面的步骤没有问题，那么表示类可以顺利装载到系统中，此时，类才会开始执行Java字节码(即，到了初始化阶段，才真正开始执行类中定义的Java代码)
  • 初始化阶段的重要工作是执行类的初始化方法：()方法
  • 该方法仅能由Java编译器生成并由JVM调用，程序开发者无法自定义一个同名方法，更无法直接在Java程序中调用该方法，虽然该方法也是由字节码指令所组成
  • 它是由类静态成员的赋值语句以及static语句块合并产生的
    在这里插入图片描述
说明
  • 在加载一个类之前，虚拟机总是会试图加载该类的父类，因此父类的总是在子类之前被调用，也就是说，父类的static块优先级高于子类------(由父及子，静态先行)
  • Java编译器并不会为所有的类都产生初始化方法，有些类编译成字节码后，不会包含方法
  • 一个类中并没有声明任何的类变量，也没有静态代码块时
  • 一个类中声明类变量，但是没有明确使用类变量的初始化语句以及静态代码块来执行初始化操作时
  • 一个类中包含static final修饰的基本数据类型的字段，这些类字段初始化语句采用编译时常量表达式

在这里插入图片描述

/**
 * 说明：使用static + final修饰的字段的显示赋值操作，到底是在哪个阶段进行的赋值
 * 情况1：在链接阶段的准备环节赋值
 * 情况2：在初始化阶段赋值
 *
 * 结论：在链接阶段的准备环节赋值
 * ①对于基本数据类型的字段来说，使用static final修饰，显示赋值(直接赋值常量，非调用方法)在链接阶段的准备环节赋值
 * ②对于String来说，如使用字面量赋值，使用static final修饰的话，显示赋值在链接阶段的准备环节赋值
 *
 * 初始化<clinit>()中赋值的情况
 * 排除上述在准备环节赋值的情况之外的情况
 * 最终结论：使用static + final修饰，且显示赋值不涉及到方法或构造调用的基本数据类型或String类型的显示赋值，是在链接阶段的准备环节进行
 */
public class InitializationTest2 {
    public static int a = 1;  //在初始化阶段<clinit>赋值
    public static final int INT_CONSTANT = 10;  //在链接阶段的准备环节赋值
    public static final Integer INTEGER_CONSTANT1 = Integer.valueOf(100);//在初始化阶段<clinit>赋值
    public static Integer INTEGER_CONSTANT2 = Integer.valueOf(1000);//在初始化阶段<clinit>赋值

    public static final String s1 = "helloworld1"; //在链接阶段的准备环节赋值
    public static final String s0 = new String("helloworld0");//在初始化阶段<clinit>赋值

    public static final int NUM1 = 2;//在链接阶段的准备环节赋值
    public static final int NUM2 = new Random().nextInt(10);//在初始化阶段<clinit>赋值
}
//字节码--<clinit>
 0 iconst_1
 1 putstatic #2 <com/chapter11/InitializationTest2.a>
 4 bipush 100
 6 invokestatic #3 <java/lang/Integer.valueOf>
 9 putstatic #4 <com/chapter11/InitializationTest2.INTEGER_CONSTANT1>
12 sipush 1000
15 invokestatic #3 <java/lang/Integer.valueOf>
18 putstatic #5 <com/chapter11/InitializationTest2.INTEGER_CONSTANT2>
21 new #6 <java/lang/String>
24 dup
25 ldc #7 <helloworld0>
27 invokespecial #8 <java/lang/String.<init>>
30 putstatic #9 <com/chapter11/InitializationTest2.s0>
33 new #10 <java/util/Random>
36 dup
37 invokespecial #11 <java/util/Random.<init>>
40 bipush 10
42 invokevirtual #12 <java/util/Random.nextInt>
45 putstatic #13 <com/chapter11/InitializationTest2.NUM2>
48 return
()线程安全性
  • 对于()方法的调用，也就是类的初始化，虚拟机会在内部确保其多线程环境中的安全性
  • 虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程会执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕
  • 因为函数()带锁线程是安全的，如果一个类的()方法中有耗时很长的操作，就可能造成多个线程阻塞，引发死锁，并且这种死锁很难发现，因为看起来没有可用的锁信息
  • 如果之前的线程成功加载了类，则等在队列中的线程就没有机会再执行()方法了，那么当需要使用这个类时，虚拟机会直接返回它已经准备好的信息
//死锁例子
class staticA {
    static {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {

        }
        try {
            Class.forName("com.chapter11.staticB");
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("StaticA init OK");
    }
}
class staticB {
    static {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {

        }
        try {
            Class.forName("com.chapter11.staticA");
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("StaticB init OK");
    }
}
public class StaticDeadLockMain extends Thread{
    private char flag;
    public StaticDeadLockMain(char flag) {
        this.flag = flag;
        this.setName("Thread" + flag);
    }

    @Override
    public void run() {
        try {
            Class.forName("com.chapter11.static" + flag);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        StaticDeadLockMain sdlm1 = new StaticDeadLockMain('A');
        StaticDeadLockMain sdlm2 = new StaticDeadLockMain('B');
        sdlm1.start();
        sdlm2.start();
    }
}
主动使用VS被动使用
主动使用
  • Class只有在必须首次使用的时候才会被装载，Java虚拟机不会无条件地装载Class类型，Java虚拟机规定，一个类或接口在初次使用前，必须进行初始化，这里指主动使用，主动使用有下面几种情况
  • 当创建一个类的实例时，比如使用new关键字，通过反射，克隆，反序列化
  • 当调用类的静态方法时，即当使用了字节码invokestatic指令
package com.chapter11;

import org.junit.Test;

import java.io.*;

/**
 * 当创建一个类的实例时，比如使用new关键字，通过反射，克隆，反序列化
 * 当调用类的静态方法时，即当使用了字节码invokestatic指令
 */
class Order implements Serializable{
    static {
        System.out.println("Order类的初始化");
    }

    public static void method1() {
        System.out.println("order method1()... ...");
    }
}
public class ActiveUse1 {
    public static void main(String[] args) {
        Order order = new Order();
    }
    @Test
    //当调用类的静态方法时
    public void test3() {
        Order.method1();  //0 invokestatic #4 <com/chapter11/Order.method1>
    }
    //序列化过程
    @Test
    public void testSerializable() {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("order.dat"));
            oos.writeObject(new Order());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //反序列化
    @Test
    public void  testDeSerializable() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("order.dat"));
            Object o = ois.readObject();
            if (o instanceof Order) {
                Order order = (Order) o;
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
  • 当使用类，接口的静态字段时(finl特殊考虑)，如getstatic或putstatic指令(对应访问变量，赋值变量)
class User {
    public static int num = 1;
    public static final int num1 = 2;
    public static final int num2 = new Random().nextInt(10);

    static {
        System.out.println("User类初始化");
    }
}

interface CompareA {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareA的初始化");
        }
    };
    public static final int NUM1 = 1;
    public static final int NUM2 = new Random().nextInt(10);
}

public class ActiveUser2 {
    /**
     * 执行结果--执行clinit
     * User类初始化
     * 1
     */
    @Test
    public void test1() {
        System.out.println(User.num);
    }

    /**
     * 执行结果--不执行clinit
     * 1
     */
    @Test
    public void test2() {
        System.out.println(User.num1);
    }

    /**
     * 执行结果--会执行clinit
     * User类初始化
     * 7
     */
    @Test
    public void test3() {
        System.out.println(User.num2);
    }

    /**
     * 执行结果
     *  1
     */
    @Test
    public void test4() {
        System.out.println(CompareA.NUM1);
    }
    /**
     * 执行结果
     *  CompareA的初始化
     *  9
     */
    @Test
    public void test5() {
        System.out.println(CompareA.NUM2);
    }
}
  • 当使用java.lang.reflect包中的方法反射类的方法时，如Class.forName(“className”)
public class ActiveUse3 {
    /**
     * 此处使用的Order为ActiveUse1中的Order类
     * 执行结果
     * Order类的初始化
     */
    @Test
    public void test1() {
        try {
            Class<?> clazz = Class.forName("com.chapter11.Order");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
  • X当初始化子类时，发现父类没有初始化，需要触发其父类的初始化
 /**
     * 执行结果
     * Father类的初始化过程
     * Son类的初始化过程
     * 1
     */
    @Test
    public void test2() {
        System.out.println(Son.num);
    }
class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}
class Son extends Father {
    static {
        System.out.println("Son类的初始化过程");
    }
    public static int  num = 1;
}
  • 一个接口定义了default方法，那直接实现或间接实现该接口类的初始化，该接口要在其之前被初始化
  • 当虚拟机启动时，用户需要指定一个要执行的主类(包含main方法的那个类)，虚拟机会先初始化这个主类
  • 当初次调用MethodHandle实例时，初始化该MethodHandle指向的方法所在的类(涉及解析REF_getStatic,REF_putStatic,REF_invokeStatic方法句柄对应的类)
  • 针对X项的补充，当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但这条规则不适用于接口
  • 在初始化一个类时，并不会先初始化它所实现的接口
  • 在初始化一个接口时，并不会先初始化它的父接口
 /**
     * Father类的初始化过程--(初始化类时，并不会先初始化它所实现的接口)
     * Son类的初始化过程
     * 1
     */
    @Test
    public void test3() {
        System.out.println(Son.num);
    }

    /**
     * 执行结果
     * CompareC的初始化---初始化一个接口时，不会初始化它的父接口
     */
    @Test
    public void test4() {
        System.out.println(compareC.num1);
    }
}
class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}
class Son extends Father implements compareB{
    static {
        System.out.println("Son类的初始化过程");
    }
    public static int  num = 1;
}
interface compareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };
}
interface compareC extends compareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareC的初始化");
        }
    };
    int num1 = new Random().nextInt(10);
}
  • 因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化，只有当程序员首次使用特定接口的静态字段时，才会导致该接口的初始化
 @Test
    public void test5() {
        System.out.println(Son.num);
    }
class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}
class Son extends Father implements compareB{
    static {
        System.out.println("Son类的初始化过程");
    }
    public static int  num = 1;
}
interface compareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };
    public default void method1() {
        System.out.println("compareB--method1");
    }
}
//执行结果
Father类的初始化过程
CompareB的初始化
Son类的初始化过程
1
  • 针对JDK7，JVM启动的时候通过引导类加载器加载一个初始类，这个类在调用public static void main(String[] args)方法之前被链接和初始化，这个方法的执行将依次导致所需的类的加载，链接和初始化。
被动使用
  • 被动使用不会引起类的初始化，并不是代码中出现的类，就一定会被加载或者初始化。如果不符合主动使用的条件，类就不会初始化
  • 当访问一个静态字段时，只有真正声明这个字段的类才会被初始化
  • 当通过子类引用父类的静态变量，不会导致此类的初始化
  • 通过数组定义类引用，不会触发此类的初始化
package com.chapter11;

import org.junit.Test;

/**
 * Administrator
 * 2024/5/31
 */
class Parent {
    static {
        System.out.println("Parent初始化");
    }
    public static int num = 1;
}
class Child extends Parent {
    static {
        System.out.println("Child初始化");
    }
}
public class PassiveUse1 {
    /**
     * 注：没有初始化不代表没有加载
     * 执行结果
     * Parent初始化
     * 1
     */
    @Test
    public void test1() {
        System.out.println(Child.num);
    }

    /**
     * 执行结果
     * 空
     */
    @Test
    public void test2() {
        Parent[] parents = new Parent[10];
    }

    /**
     * * 执行结果
     *   Parent初始化
     */
    @Test
    public void test3() {
        Parent[] parents = new Parent[10];
        parents[0] = new Parent();
    }
}
  • 引用常量不会触发此类或接口的初始化，因为常量在链接阶段就已经被显示赋值了
class Person {
    static {
        System.out.println("Person类的初始化");
    }
    public final static int NUM = 1;
    public final static int NUM1 = new Random().nextInt(10);
}
public class PassiveUse2 {

    /**
     * 执行结果--没有执行初始化
     * 1
     */
    @Test
    public void test1() {
        System.out.println(Person.NUM);
    }
    /**
     * 执行结果
     * Person类的初始化
     * 1
     */
    @Test
    public void test2() {
        System.out.println(Person.NUM1);
    }
    /**
     * 执行结果
     * 2
     */
    @Test
    public void test3() {
        System.out.println(SerialA.NUM1);
    }
    /**
     * 执行结果
     * SerialA的初始化
     * 5
     */
    @Test
    public void test4() {
        System.out.println(SerialA.NUM2);
    }
}
interface SerialA {
    public static final Thread t = new Thread() {
        {
            System.out.println("SerialA的初始化");
        }
    };
    int NUM1 = 2;
    int NUM2 = new Random().nextInt(10);   //赋值操作需要在clinit中执行
}
  • 调用ClassLoader类的loadClass()方法加载一个类，并不对类的主动使用，不会导致类的初始化
//执行结果为空，表示没有显示初始化类
@Test
    public void test5() {
        try {
            Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass("com.chapter11.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
类的Using(使用)
  • 开发人员可以在程序中访问和调用它的静态类成员信息(静态字段、静态方法)，或者使用new关键字为其创建对象实例
类的Unloading(卸载)
方法区的垃圾回收
  • 类、类加载器、类实例之前的引用关系
  • 在类加载器的内部实现中，用一个Java集合来存放所加载类的引用，另一方面，一个Class对象总是会引用它的类加载器，调用Class对象的getClassLoader()方法，就能获得它的类加载器，由此可见，代表某个类的Class实例与其类的加载器之前为双向关联关系
  • 一个类的实例总是引用代表这个类的Class对象。在Object类中定义了getClass()方法，这个方法返回代表对象所属类的Class对象的引用，此外，所有的Java类都有一个静态属性class,它引用代表这个类的Class对象
  • 类的生命周期
  • 当Sample类被加载、链接、初始化后，它的生命周期就开始了，当代表Sample类的class对象不再被引用，即不可触及时，Class对象就会结束生命周期，Sample类在方法区内的数据也会被卸载，从而结束Sample类的生命周期
  • 一个类何时结束生命周期，取决于代表它的Class对象何时结束生命周期
    在这里插入图片描述
  • loader1变量和obj变量间接应用代表Sample类的Class对象，而objClass变量则直接引用它
  • 如果程序运行过程中，将上图左侧三个引用变量置为null,此时sample对象结束生命周期，MyClassLoader对象结束生命周期，代表Sample类的Class对象也结束生命周期，Sample类在方法区内的二进制数据被卸载
  • 当再次有需要时，会检查Sample类的Class对象是否存在，如果存在则直接使用，不再重新加载，如果不存在Sample类会被重新加载，在Java虚拟机的堆区会生成一个新的代表Sample类的Class实例
  • 类的卸载
  • 启动类加载器加载的类型在整个运行期间是不可能被卸载的(jvm和jls规范)
  • 被系统类加载器和扩展类加载器加载的类型在运行期间不太可能被卸载，因为系统类加载器实例或者扩展类的实例基本上在整个运行期间总能直接或间接的访问到，其达到unreachable的可能性小
  • 被开发者自定义的类加载器实例加载的类型只有在很简单的上下文环境中才能被卸载，而且一般还要借助于强制调用虚拟机的垃圾收集功能才可以做到，可以预想，稍微复杂点的应用场景中，被加载的类型在运行期间也是几乎不太可能被卸载的
  • 综上几点，一个已经加载的类型被卸载的几率很小至少被卸载的时间是不确定的，同时可以看出，开发者在开发代码时，不应该对虚拟机的类型卸载做任何假设的前提下，来实现系统中的特定功能

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1720843.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

龙芯3A4000+FPGA云终端解决方案，搭载昆仑国产化固件,支持UOS、银河麒麟等国产操作系统

龙芯3A4000+FPGA云终端解决方案，搭载昆仑国产化固件,支持UOS、银河麒麟等国产操作系统

龙芯云终端基于国产化龙芯高性能四核3A4000处理器平台的国产自主可控解决方案&#xff0c;搭载昆仑国产化固件,支持UOS、银河麒麟等国产操作系统&#xff0c;满足国产化信息安全运算的需求&#xff0c;实现从硬件、操作系统到应用的完全国产、自主、可控&#xff0c;是国产信息…
阅读更多...
AI 赋能前端 -- 文本内容概要生成

AI 赋能前端 -- 文本内容概要生成

幸福不在于你获得了什么，而在于你比他人多获得了什么 是比较出来的 大家好，我是柒八九。一个专注于前端开发技术/Rust及AI应用知识分享的Coder 此篇文章所涉及到的技术有 OpenAILangChainRust/WebAssemblyWeb Workerreact+ts+vite配置环境变量(env)因为，行文字数所限，有些概…
阅读更多...
常用电机测试方法的介绍与功能实现（M测试方法）

常用电机测试方法的介绍与功能实现（M测试方法）

目录 概述 1 常用电机测速方法简介 1.1 方法概览 1.2 编码器测速方法 2 M法测速 2.1 理论描述 2.2 实现原理 2.3 速度计算方法 3 功能实现 3.1 功能介绍 3.2 代码实现 3.2.1 使用STM32Cube配置参数 3.2.2 脉冲计数功能 3.2.3 测速函数 4 测试 概述 本文主要介绍…
阅读更多...
Mybatis-plus 更新或新增时设置某些字段值为空

Mybatis-plus 更新或新增时设置某些字段值为空

方式一 在实体中设置某个字段为的注解中 TableField(updateStrategy FieldStrategy.IGNORED)private Date xxxxxxTime;通过这种方式会指定更新时该字段的策略&#xff0c;通常情况下updateById这种会根据字段更新&#xff0c;通常都会判断null 以及空值 指定 updateStrategy …
阅读更多...
521源码网-免费网络教程-Cloudflare使用加速解析-优化大陆访问速度

521源码网-免费网络教程-Cloudflare使用加速解析-优化大陆访问速度

Cloudfalre 加速解析是由 心有网络 向中国大陆用户提供的公共优化服务 接入服务节点: cf.13d7s.sit 接入使用方式类似于其它CDN的CNAME接入&#xff0c;可以为中国大陆用户访问Cloudflare网络节点大幅度加速&#xff0c;累计节点130 如何接入使用 Cloudflare 加速解析&#…
阅读更多...
某咨询公司的大数据解决方案介绍（32页PPT）

某咨询公司的大数据解决方案介绍（32页PPT）

方案介绍&#xff1a; 本咨询公司的大数据平台解决方案以企业实际需求为出发点&#xff0c;结合先进的大数据技术和行业经验&#xff0c;为企业提供一站式的大数据服务。通过实时数据收集与处理、深度数据分析与挖掘、可视化数据展示以及灵活的数据应用与扩展&#xff0c;帮助…
阅读更多...
[.NET开发者的福音]一个方便易用的在线.NET代码编辑工具.NET Fiddle

[.NET开发者的福音]一个方便易用的在线.NET代码编辑工具.NET Fiddle

前言 今天给大家分享一个方便易用的.NET在线代码编辑工具&#xff0c;能够帮助.NET开发人员快速完成代码编写、测试和分享的需求&#xff08;.NET开发者的福音&#xff09;&#xff1a;.NET Fiddle。 .NET Fiddle介绍 我们可以不用再担心环境与庞大的IDE安装的问题&#xff0…
阅读更多...
frp之XTCP实现内网穿透家用电脑远程桌面公司电脑

frp之XTCP实现内网穿透家用电脑远程桌面公司电脑

官网XTCP介绍 《XTCP介绍》 实现图 fprs.toml # frps 服务端口&#xff08;不填&#xff0c;则默认&#xff1a;7000&#xff09; bindPort 81 auth.token "token 令牌"公司电脑frpc.toml serverAddr "frps公网服务器域名或ip" serverPort frps 服…
阅读更多...
小程序配置自定义tabBar及异形tabBar配置操作

小程序配置自定义tabBar及异形tabBar配置操作

什么是tabBar&#xff1f; 小程序的tabbar是指小程序底部的一组固定导航按钮&#xff0c;通常包含2-5个按钮&#xff0c;用于快速切换小程序的不同页面。每个按钮都有一个图标和文本标签&#xff0c;点击按钮可以切换到对应的页面。tabbar通常放置在小程序的底部&#xff0c;以…
阅读更多...
springboot基本使用十一（自定义全局异常处理器）

springboot基本使用十一（自定义全局异常处理器）

例如&#xff1a;我们都知道在java中被除数不能为0&#xff0c;为0就会报by zero错误 RestController public class TestController {GetMapping("/ex")public Integer ex(){int a 10 / 0;return a;}} 打印结果&#xff1a; 如何将这个异常进行处理&#xff1f; 创…
阅读更多...
智慧医院物联网建设-统一管理物联网终端及应用

智慧医院物联网建设-统一管理物联网终端及应用

近年来&#xff0c;国家卫健委相继出台的政策和评估标准体系中&#xff0c;都涵盖了强化物联网建设的内容。物联网建设已成为智慧医院建设的核心议题之一。 作为医院高质量发展的关键驱动力&#xff0c;物联网的顶层设计与网络架构设计规划&#xff0c;既需要结合现代信息技术的…
阅读更多...
NetApp财季报告亮点：全闪存阵列需求强劲，云计算收入增长放缓但AI领域前景乐观

NetApp财季报告亮点：全闪存阵列需求强劲，云计算收入增长放缓但AI领域前景乐观

在最新的财季报告中&#xff0c;NetApp的收入因全闪存阵列的强劲需求而显著增长。截至2024年4月26日的2024财年第四季度&#xff0c;NetApp的收入连续第三个季度上升&#xff0c;达到了16.7亿美元&#xff0c;较前一年同期增长6%&#xff0c;超出公司指导中值。净利润为2.91亿美…
阅读更多...
从openstack环境中将服务器镜像导出的简单办法

从openstack环境中将服务器镜像导出的简单办法

1 登录openstack的页面&#xff0c;找到计划导出的主机信息。 通过实例名称&#xff0c; IP地址&#xff0c;找到对应的记录。点击实例名称&#xff0c;进入详情页。 在这里主要可以知道&#xff0c;当前主机在服务器上的文件ID&#xff0c;可以按这个ID去找对应的目录。 还可…
阅读更多...
自定义对象池BasePooledObjectFactory的使用

自定义对象池BasePooledObjectFactory的使用

项目中用到了apache的对象池来管理文件导出相关资源连接和回收功能&#xff0c;因此花点时间简单了解下对象池相关使用&#xff0c;做点记录。 一. 连接池 频繁的建立和关闭连接&#xff0c;会极大的降低系统的性能&#xff0c;而连接池会在初始化的时候会创建一定数量的连接…
阅读更多...
HTML静态网页成品作业(HTML+CSS)—— 冶金工程专业展望与介绍介绍网页(2个页面)

HTML静态网页成品作业(HTML+CSS)—— 冶金工程专业展望与介绍介绍网页(2个页面)

&#x1f389;不定期分享源码&#xff0c;关注不丢失哦 文章目录 一、作品介绍二、作品演示三、代码目录四、网站代码HTML部分代码 五、源码获取 一、作品介绍 &#x1f3f7;️本套采用HTMLCSS&#xff0c;未使用Javacsript代码&#xff0c;共有2个页面。 二、作品演示 三、代…
阅读更多...
教育数字展馆助力全球教育传播，科技引领数字化教育潮流

教育数字展馆助力全球教育传播，科技引领数字化教育潮流

一、教育数字展馆助力教育传播 1、提高教育资源的可及性 教育数字展馆通过VR和WEB3D技术&#xff0c;将丰富的教育资源呈现在用户面前。不论是名校的经典课程&#xff0c;还是专家的精彩讲座&#xff0c;均可通过教育数字展馆实现线上展示。用户只需登录平台&#xff0c;即可…
阅读更多...
手机耳机哪个品牌音质好

手机耳机哪个品牌音质好

在寻找音质出色的手机耳机时&#xff0c;品牌选择显得尤为重要。市场上众多知名品牌提供了各式各样的耳机产品&#xff0c;它们在音质、降噪功能、设计等方面各有千秋。以下是一些在音质上表现优异的手机耳机品牌的分析&#xff1a; 索尼&#xff1a;索尼的耳机以其卓越的降噪技…
阅读更多...
jenkins插件之plot

jenkins插件之plot

plot是一个生成图表的插件&#xff0c;这里我用于可视化phploc统计的数据 插件安装 进入 Dashboard --> 系统管理 --> 插件管理 --> Available plugins 搜索plot安装生成phploc分析数据 Dashboard --> 您的项目 --> Configuration点击 Build Steps点击 增加构…
阅读更多...
使用 union 判断系统大小端

使用 union 判断系统大小端

使用 union 判断系统大小端 大小端介绍字节序内存布局小端大端 确定大小端的方法union指针 大小端介绍 字节序 内存布局 栈空间向低地址生长&#xff0c;堆空间向高地址生长。 小端 大端 确定大小端的方法 union #include <stdio.h>// 定义一个联合体&#xff0c;包…
阅读更多...
随身wifi和手机流量卡，你知道该怎么选吗？

随身wifi和手机流量卡，你知道该怎么选吗？

网络已经成为我们这个时代的代名词&#xff01; 那么&#xff0c;在上网的时代&#xff0c;我们有很多问题都要考虑&#xff0c;比如如何选择上网方式&#xff0c;是选择一张流量卡&#xff0c;还是一个随身WIFI&#xff1f; 听小编一句劝&#xff0c;先不要着急买&#xff0c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023