JVM理解-day01

最新推荐文章于 2021-09-06 16:46:02 发布
最新推荐文章于 2021-09-06 16:46:02 发布
阅读量169 收藏
点赞数
分类专栏： 学习 文章标签： jvm java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QYH7777/article/details/106879106
版权

-JVM理解

类加载

在Java代码中，类型（class）的加载、连接与初始化过程都是在程序运行期间完成的

在cmd可以输入这两个命令查看jvm的情况

-jconsole

 

 

选择不安全连接

 

-jvisualvm

 

类的加载、连接与初始化

加载

  • 查找并加载类的二进制数据

连接

  • 验证：确保被加载的类的正确性

  • 准备：为类的静态变量分配内存，并将其初始化为默认值（如public static int a = 1）,在这一步只是为a分配了内存，且将其初始化为了0（int型默认值为0）

  • 解析：把类中的符号引用转换为直接引用

初始化

  • 为类的静态变量赋予正确的初始值（这时 a=1）

类的使用和卸载

  • 使用

  • 卸载

Java程序对类的使用方式可以分为两种

  • 主动使用

  • 被动使用

所有的Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”的时候才初始化他们

public class MyTest4 {
    public static void main(String[] args) {
        MyParent4 myParent4 = new MyParent4();
        System.out.println(myParent4.getClass());
        System.out.println("=========");
        MyParent4 myParent5 = new MyParent4();
    }
}
​
class MyParent4{
    static{
        System.out.println("MyParent4 static block");
    }
}
MyParent4 static block
class com.qyh.jvm.classloader.MyParent4
=========

可以看到只初始化了一次

主动使用（七种）

  • 创建一个类的实例

  • 访问某个类或接口的静态变量，或者对该静态变量赋值

  • 调用类的静态方法

  • 反射（如Class.forName("com.qyh.Test")）

  • 初始化一个类的子类（初始化子类，就会初始化父类，如果父类还有父类那就一直往上初始化）

  • Java虚拟机启动时被标明为启动类的类（含Main方法）

  • JDK1.7开始提供的动态语言支持

除了以上七种情况，其它使用Java类的方式都被看做是对类的被动使用，不会导致类的初始化

类的加载

类的加载指得是将类的.class文件中的二进制数据读入内存中，将其放入在运行时数据区的方法区（JDK1.8之后移除了方法区，将其移至源空间，位于本地内存中），然后在内存中创建一个java.lang.Class对象（规范并未说明对象位于哪里，Hotspot虚拟机将其放在了方法区中）用来封装在方法区的数据结构

  • 加载.class文件的方式

  1. 从本地系统中直接中加载

  2. 通过网络下载.class 文件

  3. 从zip，jar等归档文件中加载.class文件

  4. 从专有的数据库中提取.class 文件

  5. 将Java源文件动态编译为.class文件（如jsp中的java代码）

package com.qyh.jvm.classloader;
​
public class MyTest1 {
​
    public static void main(String[] args) {
//        System.out.println(MyChild1.str2);
        System.out.println(MyChild1.str);
    }
​
}
​
class MyParent1{
    public static String str="hello world";
    static{
        System.out.println("MyParent1 static block");
    }
}
​
class MyChild1 extends MyParent1{
    public static String str2 = "welcome";
    static{
        System.out.println("MyChild1 static block");
    }
}

运行结果

MyParent1 static block
hello world

思考：虽然MyChild1没有初始化，但是此时MyChild1加载了么？

XX:+TraceClassLoading #用于追踪类加载信息并打印出来

运行，查看控制台打印的信息

 

 

可以看出，MyChild1，尽管没有初始化，但是仍然加载了的！

package com.qyh.jvm.classloader;
​
public class MyTest1 {
​
    public static void main(String[] args) {
        System.out.println(MyChild1.str2);
//        System.out.println(MyChild1.str);
    }
​
}
​
class MyParent1{
    public static String str="hello world";
    static{
        System.out.println("MyParent1 static block");
    }
}
​
class MyChild1 extends MyParent1{
    public static String str2 = "welcome";
    static{
        System.out.println("MyChild1 static block");
    }
}

运行结果

MyParent1 static block
MyChild1 static block
welcome

编译期常量与运行期常量的区别

package com.qyh.jvm.classloader;
​
//常量在编译阶段会被存入到调用这个方法所在的类的常量池中，(str就放在了MyTest2的常量池中)
//本质上，调用类并没有直接引用到定义常量的类，因此并不会触发定义常量的类的初始化
//运行结果仅仅为hello world
//注意：这里只是将常量存放到了MyTest2的常量池中，之后的MyTest2与MyParent2就没有任何关系了
//甚至我们可以吧MyParent2的class文件删除掉，仍然可以运行出结果
​
public class MyTest2 {
​
    public static void main(String[] args) {
        System.out.println(MyParent2.str);
    }
​
}
​
class MyParent2{
    public static final String str="hello world";
​
    static {
        System.out.println("MyParent2 static block");
    }
​
}
​

为了验证删除class文件，我们用记事本编译，运行一次后，删除掉MyParent2的.class文件

 

反编译结果：

D:\Javaweb\jvm_study>cd out
系统找不到指定的路径。
​
D:\Javaweb\jvm_study>cd target
​
D:\Javaweb\jvm_study\target>cd classes
​
D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #4                  // String hello world
       5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}
​

关于助记符

package com.qyh.jvm.classloader;
​
//常量在编译阶段会被存入到调用这个方法所在的类的常量池中，(str就放在了MyTest2的常量池中)
//本质上，调用类并没有直接引用到定义常量的类，因此并不会触发定义常量的类的初始化
//运行结果仅仅为hello world
//注意：这里只是将常量存放到了MyTest2的常量池中，之后的MyTest2与MyParent2就没有任何关系了
//甚至我们可以吧MyParent2的class文件删除掉，仍然可以运行出结果
​
//在Terminal反编译后 D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
//查看到结果：
/*
    助记符：
     ldc 表示将int，float或是String类型的常量值从常量池推送至栈顶
     bipush 表示将单字节（-128~127）的常量值推送至栈顶
     sipush  表示将一个短整型常量值（-32768~32767）推送至栈顶
     iconst_1   表示将int类型的1推送至栈顶（iconst_0 ~ iconst_5 表示int类型0~5
     iconst_m1  表示将int类型-1推送至栈顶
     超过5或者小于-1之后便会变成bipush以此推递下去
​
 */
​
public class MyTest2 {
​
    public static void main(String[] args) {
        System.out.println(MyParent2.m);
    }
​
}
​
class MyParent2{
​
    public static final String str="hello world";
​
    public static final short s=127;
​
    public static final int i=128;
​
//    public static final int m=1;
//    public static final int m=-2;
//    public static final int m=-1;
    public static final int m=0;
//        public static final int m=5;
//    public static final int m=6;
​
    static {
        System.out.println("MyParent2 static block");
    }
​
}

 

反编译

D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: sipush        128
       6: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       9: return
}
​
D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: iconst_1
       4: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       7: return
}
​
D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: iconst_2
       4: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       7: return
}
​
D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: bipush        6
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       8: return
}
​
D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: iconst_m1
       4: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       7: return
}
​
D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: bipush        -2
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       8: return
}
​
D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest2
警告: 二进制文件com.qyh.jvm.classloader.Mytest2包含com.qyh.jvm.classloader.MyTest2
Compiled from "MyTest2.java"
public class com.qyh.jvm.classloader.MyTest2 {
  public com.qyh.jvm.classloader.MyTest2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: iconst_0
       4: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
       7: return
}

注意：

package com.qyh.jvm.classloader;
​
import java.util.UUID;
​
/*
    当一个常量的值并非编译期间可以确定的，那么其值就不会被放到调用类的常量池中，
    这时在程序运行时，会导致主动使用这个常量所在的类，显然会导致这个类初始化
 */
​
public class MyTest3 {
​
    public static void main(String[] args) {
        System.out.println(MyParent3.str);
    }
​
}
​
class MyParent3{
​
    public static final String str = UUID.randomUUID().toString();
​
    static {
        System.out.println("MyParent3 static code");
    }
​
}
​

运行结果：

MyParent3 static code
0a9218e8-c54d-4318-961c-804869f64496
​

数组类型创建的本质分析

package com.qyh.jvm.classloader;
​
/*
    对于数组实例来说，其类型是由JVM在运行期动态生成的，表示为[Lcom.qyh.jvm.classloader.MyParent4
    这种形式。动态生成的类型，其父类型就是Object。
    对于数组来说，JavaDoc经常将构成数组的元素称为Component，实际上就是将数组降低一个维度后的类型。
​
    助记符：
    anewarray 表示创建一个引用类型的（如：类、接口、数组）数组，并将其引用值压入栈顶
    newarray 表示创建一个指定的原始类型（如：int、float、char等）的数组，并将其引用值压入栈顶
 */
​
public class MyTest4 {
    public static void main(String[] args) {
//        MyParent4 myParent4 = new MyParent4();
//        System.out.println(myParent4.getClass());
//        System.out.println("=========");
        MyParent4[] myParent4s = new MyParent4[1];
        System.out.println(myParent4s.getClass());
​
        MyParent4[][] myParent4s1 = new MyParent4[1][1];
        System.out.println(myParent4s1.getClass());
​
        System.out.println(myParent4s.getClass().getSuperclass());
        System.out.println(myParent4s1.getClass().getSuperclass());
​
        System.out.println("===============");
​
        int[] ints = new int[1];
        System.out.println(ints.getClass());
        System.out.println(ints.getClass().getSuperclass());
​
        char[] chars = new char[1];
        System.out.println(chars.getClass());
​
​
        boolean[] b = new boolean[1];
        System.out.println(b.getClass());
​
        short[] s = new short[1];
        System.out.println(s.getClass());
​
        byte[] bytes = new byte[1];
        System.out.println(bytes.getClass());
​
    }
}
​
class MyParent4{
    static{
        System.out.println("MyParent4 static block");
    }
}
​
MyParent4 static block
class com.qyh.jvm.classloader.MyParent4
######################################################
class [Lcom.qyh.jvm.classloader.MyParent4;
class [[Lcom.qyh.jvm.classloader.MyParent4;
class java.lang.Object
class java.lang.Object
===============
class [I
class java.lang.Object
class [C
class [Z
class [S
class [B

反编译：

D:\Javaweb\jvm_study\target\classes>javap -c com.qyh.jvm.classloader.Mytest4
警告: 二进制文件com.qyh.jvm.classloader.Mytest4包含com.qyh.jvm.classloader.MyTest4
Compiled from "MyTest4.java"
public class com.qyh.jvm.classloader.MyTest4 {
  public com.qyh.jvm.classloader.MyTest4();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return
​
  public static void main(java.lang.String[]);
    Code:
       0: iconst_1
       1: anewarray     #2                  // class com/qyh/jvm/classloader/MyParent4
       4: astore_1
       5: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       8: aload_1
       9: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      12: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      15: iconst_1
      16: iconst_1
      17: multianewarray #6,  2             // class "[[Lcom/qyh/jvm/classloader/MyParent4;"
      21: astore_2
      22: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      25: aload_2
      26: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      29: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      32: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      35: aload_1
      36: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      39: invokevirtual #7                  // Method java/lang/Class.getSuperclass:()Ljava/lang/Class;
      42: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      45: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      48: aload_2
      49: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      52: invokevirtual #7                  // Method java/lang/Class.getSuperclass:()Ljava/lang/Class;
      55: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      58: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      61: ldc           #8                  // String ===============
      63: invokevirtual #9                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      66: iconst_1
      67: newarray       int
      69: astore_3
      70: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      73: aload_3
      74: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      77: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      80: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
      83: aload_3
      84: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
      87: invokevirtual #7                  // Method java/lang/Class.getSuperclass:()Ljava/lang/Class;
      90: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      93: iconst_1
      94: newarray       char
      96: astore        4
      98: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
     101: aload         4
     103: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
     106: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
     109: iconst_1
     110: newarray       boolean
     112: astore        5
     114: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
     117: aload         5
     119: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
     122: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
     125: iconst_1
     126: newarray       short
     128: astore        6
     130: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
     133: aload         6
     135: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
     138: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
     141: iconst_1
     142: newarray       byte
     144: astore        7
     146: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
     149: aload         7
     151: invokevirtual #4                  // Method java/lang/Object.getClass:()Ljava/lang/Class;
     154: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
     157: return
}

结论：

只有主动引用才会初始化类，第一次new MyParent4可以初始化，并且打印对象的类，可以看到来自于com.qyh.jvm.classloader.MyParent4

当我们创建MyParent4的一维和二维数组的时候，并没有主动引用MyParent4这个类，通过getclass我们看到我们创建的实例来自[Lcom.XXX和[[Lcom.XXX这个是虚拟机在编译的时候相当于动态代理给我们实现的

QYH7777
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（4）JVM 整体结构理解
夜风灵波的博客
05-12 172
目录前言一、JVM的整体结构1、JDK 整体结构图2、JVM 整体结构图3、JVM 类加载子系统4、JVM 字节码执行引擎5、JVM 线程栈、本地方法栈和程序计数器6、JVM 堆区7、JVM 方法区总结 前言 前面三篇文章围绕进行类加载之前的一些过程进行理解： （1）JVM 类加载之流程理解 （2）JVM 类加载之类加载器初始化 （3）JVM 类加载之双亲委派机制 那么类加载之后呢？再次把Java执行一个类的流程图放上： 从图中可以看出，类加载之后就是JVM对类的调用执行了，这个需要通过JVM的整体
java基础语法-day01
01-04
【Java基础语法-day01】 Java是一门广泛使用的高级编程语言，它由Sun Microsystems公司（现已被Oracle公司收购）于1995年发布。Java的设计目标是具有平台独立性，能够编写一次，到处运行。这得益于其跨平台的Java...
重读 JVM
weixin_34009794的博客
09-04 5178
秋招开始了，前面由于做别的事耽误了半个月，以前学的东西不用就很容易忘记。所以，这次重新阅读《深入理解 JVM 虚拟机》时，想做一个记录。将碎片的知识整合，方便自己以后阅读，同时也和大家一起分享。内容中会添加我自己的理解，其中如果有错误，欢迎大家指正。 相关阅读:1. 重拾数据结构2. 重拾操作系统3. 重拾计算机网络(未完成)）注意：以上内容会持续更新，欢迎大家关注 GitHub &amp;&...
JVM 参数 调优
alenejinping的专栏
03-04 119
/** * * JVM参数调优： * 查看某个正在运行程序jvm某个参数是否开启布尔型参数： jinfo -flag 配置项 进程编号 * Idea-terminal：1 jps -l （获得进程编号） 2 jinfo -flag PrintGCDetails 进程编号 3+表示开启 -表示未开启 * * 查看个正在运行程序jvm参数：jinfo -flags 进程编号 * Idea-terminal：1 jps -l （获得进程编号） 2 jinfo -flags 进程编号 * * ID.
JVM命令行工具介绍
clear
07-22 1109
JPS —虚拟机进程状况工具 常用参数： -l 输出Java应用程序的main class的完整包 -q 仅显示pid，不显示其它任何相关信息 -m 输出传递给main方法的参数 -v 输出传递给JVM的参数。在诊断JVM相关问题的时候，这个参数可以查看JVM相关参数的设置 jstat —虚拟机统计信息监视工具 jstat gc详解 S0C：年轻代中第一个survivor（幸存区）的容量 (字...
JVM terminated. Exit code=-1的解决方法
热门推荐
叫个锤子哟
10-10 1万+
问题截图: 右键myeclispe  -> 打开文件位置  ->找到myeclipse.ini 打开，修改Xmx XX，看起是否是大于4倍的关系
实习日记 08/18 day30理解JVM---类文件的结构
qq_43285863的博客
08-23 72
概览 现在来到了虚拟机执行子程序部分，在此部分我打算结合Java核心技术卷一的部分内容与深入理解Jvm相结合来写我对Java类的理解，从表层一直深入到底层。 Java程序就像披萨，我们把原材料备好，一股脑的塞入编译器，这边自动装盘送入JVM这个烤箱，不一会就出来了香喷喷的披萨。类是什么？类就是披萨上的原料表上的原料，Java是面向对象的，而对象从属于某一个类，原料表上可不会写具体哪一块番茄，但是我们知道我们吃到的具体的起到调味的作用的红红的东西，这个东西（对象）就是属于番茄（类）。 ...
实习日记 08/27 day37 理解JVM--从JVM理解并发part2
qq_43285863的博客
09-06 76
JVM并发理解概览线程安全锁优化后记 概览 线程安全 当多个线程访问同一个对象时，如果不用考虑这些线程在运行环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方法进行任何其他的协调操作，调用这个对象的行为都可以获得正确结果，那这个对象是线程安全的 线程安全的代码都必须具有一个特征：代码本身封装了所有必要的正确性保障手段（如互斥等待等），令调用者无需多关心多线程问题。 从强到弱的线程安全： 线程安全的实现方法： 锁优化 后记 JVM这本书到此已经看完一遍了，但是由于计算机组成原理、操作系统原理
跟我学Java-day01-java基础语法.pdf
03-07
1.2 Java语言跨平台原理（理解） Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚 拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装...
多线程-day02.docx
12-12
Java内存模型，也称为JVM内存模型，是Java程序员理解和掌握的基础知识，特别是在进行并发编程时。它描述了程序运行时数据如何在JVM内存中分布。Java内存模型主要分为以下几个部分： 1. **程序计数器**：每个线程都...
就业班JavaSE--day05 每日作业卷1
08-08
JavaSE的第五天作业主要涵盖了Java基础中的几个关键知识点，包括`Object`类、`equals()`...以上内容详细解释了JavaSE第五天作业涉及的主要概念和操作步骤，这些基础知识对于理解和处理Java程序中的常见问题至关重要。
就业班JavaSE--day05 每日作业卷2
08-08
在Java编程语言中，`Object`类是所有其他类的基类，它位于继承层次结构的顶端。`Object`类提供了所有类都具备的基本功能，包括`equals()`、`toString()`以及`...这些内容对于理解和编写健壮的Java代码至关重要。
关于使用IDEA页面跳转404以及idea创建servlet的一些小问题
QYH7777的博客
03-02 2289
今天第一次使用IDEA写web项目遇见了页面单独访问不了，页面跳转404的问题。就个人解决过程和大家分享一下。 首先，我把项目启动运行之后我发现地址栏一行和我之前用MyEclipse不一样 我的项目名叫hibernate_1,如果使用MyEclipse访问这里应该为hibernate_1,至此我都没意识到这个坑。 我的跳转代码先是这样写的 跳转不了，之后我改为 /hibernate...
javaweb URLEncoder 和 URLDecoder 用法学习
QYH7777的博客
09-21 293
URLEncoder.encode(String s, String enc)  使用指定的编码机制将字符串转换为 application/x-www-form-urlencoded 格式  URLDecoder.decode(String s, String enc)  使用指定的编码机制对 application/x-www-form-urlencoded 字符串解码。 这两个都主要针对于界...
Spring_AOP之切入点的表达方式和通知类型
QYH7777的博客
03-08 278
简单写写关于AOP切入点的表达方式和通知类型 通知类型：其中异常通知较简单便不做演示 <!--编写切面类的配置--> <bean id="myAspectXml" class="com.qyh.demo2.MyAspectXml"/> <!--配置AOP--> <aop:config> <...
MyBatis中SqlSessionBuilder、SqlsessionFactory已经Sqlsession的生命周期和作用域
QYH7777的博客
04-11 266
SqlSessionFactoryBuilder 这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着...
Mybatis中sql注入的问题
QYH7777的博客
04-11 217
MyBatis中使用sql字符串拼接的时候，要注意防止sql注入的问题。 首先说一下${}和#{}的区别 #{}：占位符，是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入 ${}：拼接符，取出的值直接拼装在sql语句中，会有安全问题，sql注入； 实例语句中：name传入值为 李四 select * from user where name...
MyBatis-一对多，多对一的映射关系（上）
QYH7777的博客
04-15 214
MyBatis很好的简化了关于Dao层的开发，本文将讲述MyBatis中如何对数据库表之间一对多和多对一关系的开发 首先建立一个简单的对应数据库表结构 teacher表中字段 student表中字段 一对多 一对多是我们经常会遇见的情况，在SQL语句中我们常用子查询的方式来解决！ 例如：现在我要 查询所有的学生信息，以及对应老师的信息 SELECT s.id,s.nam...
jvm的-Xss参数
最新发布
04-12
JVM的-Xss参数用于设置线程的栈大小。栈是用于存储线程执行时的方法调用和局部变量的内存区域。每个线程都有自己的栈，用于保存方法调用的上下文信息。 -Xss参数可以用来调整线程栈的大小。默认情况下，JVM会根据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值