nihui123

Java高并发编程详解系列-类加载

之前在写关于JVM的时候提到过类加载机制，类加载机制也是在Java面试中被经常问道的一个问题，在这篇博客中就来了解一下关于类加载的知识。

类加载

在JVM执行Java程序的时候实际上执行的编译好的class 文件，我们知道Java语言的夸平台特性其实实际上是由不同平台的虚拟机来完成的，那么整个JVM又是怎样执行这些操作的呢？就不得不提一个类加载问题，在不同平台的机器上可以运行同样的Class文件，这就说明JVM是提供了一套统一的调用过程而这个过程就是类加载过程。

类加载过程

首先类加载过程分为三个大的阶段，在这个三个阶段执行不同的操作。

1. 加载阶段
主要负责查找并且加载类的二进制文件，也就是class文件。
2. 连接阶段
a. 验证：确保类的完整性
b. 准备：为类中的变量分配内存，初始化默认值
c.解析：把符号引用变为直接引用。
3. 初始化阶段
将类的静态变量赋予正确的初始值

当JVM在使用java 命令执行class文件之后会执行的过程就是这些了。那是不是每个类都需要执行初始化操作呢呢？不是。JVM对类的初始化是有一个懒加载的机制，也就是说在这个类首次被使用的时候才会被初始化，对于这个问题，在后面我们在细说。介绍的下一个概念就是关于类的加载使用问题。

类的主动加载和被动加载

在Java虚拟机规范中提到，每个类或者是接口被Java程序首次使用的时候整个类才会被初始化。当然这个不包括动态编译实现的那些操作。

类主动加载的场景

通过new关键字初始化对象时。
通过类名直接访问静态变量或者静态方法的时候
通过反射操作获取到类对象的时候
初始化子类的时候导致父类初始化
如果这个类作为启动类来使用调用Main函数时

也就是说除了上面所列举出来的场景，其他出现的场景都是被动加载
例如

构造某个对象数组的时候
使用类的静态常量不会导致类的初始化，因为常量的存储在常量池中等等操作

单例模式详解类加载过程

public class Singleton {

    private static int a = 0;

    private static int b ;

    private static Singleton instance = new Singleton();

    private Singleton(){
        a++;
        b++;
    }

    public static Singleton getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.a);
        System.out.println(singleton.b);
    }
}

分析上面代码不难发现，这个就是一个饿汉式的单例实现方式。那么上面代码的输出结果是什么呢？为什么会出现这样的效果呢？如果我们对于代码发生变化之后又会是什么样的结果呢！

public class Singleton {

    private static Singleton instance = new Singleton();

    private static int a = 0;

    private static int b ;
    
    private Singleton(){
        a++;
        b++;
    }

    public static Singleton getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.a);
        System.out.println(singleton.b);
    }
}

会发现第二次的结果和第一次的结果是不一样的。那么怎么会出现这样的问题呢？
如果将代码改为下面的样子会有什么结果

public class Singleton {

    private static int a = 0;

    private static int b ;

    //private static Singleton instance = new Singleton();
    private static Singleton instance;

    private Singleton(){
        a++;
        b++;
    }

    public static Singleton getInstance(){
        if (instance !=null){
            instance = new Singleton();
        }
        return instance;
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.a);
        System.out.println(singleton.b);
    }
}

会发现这种代码执行的效果是跟之前的结果又是不一样的。如果将代码改为如下的样子

public class Singleton {

    static {
        System.out.println("执行了静态代码块");
    }

    private static int a = 1;

    private static int b  ;

    //private static Singleton instance = new Singleton();
    private static Singleton instance;

    private Singleton(){
        System.out.println("执行初始化方法");
        a++;
        b++;
    }

    public static Singleton getInstance(){
        System.out.println("对象实例开始创建");
        if (instance !=null){
            System.out.println("类对象没有被初始化");
            instance = new Singleton();
        }
        System.out.println("创建对象完成");
        return instance;
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println(singleton.a);
        System.out.println(singleton.b);
        System.out.println("=====通过类名直接调用====");
        System.out.println(Singleton.a);
        System.out.println(Singleton.b);
    }
}

会发现四种方式每种方式的结果都是不一样的，那么为什么会出现上面的四种方式的不同呢？

类加载阶段

类加载就是将二进制的class文件读取到内存中，将字节流表示的静态结构转换为运行时的数据结构，并在内存中生成一个java.lang.Class对象，作为访问方法区数据结构的入口。

类加载的最终产物就是在堆内存中的class对象，对于同一个类加载器来说，无论多少次同一个类加载到堆内存中，所产生的对象都是同一个。在使用的时候通过类的全类名来获取二进制数据流。那么二进制数据流的来源都有哪些呢？

运行时动态生成，例如使用动态代理来生成代理类二进制字节流。
通过网络获取二进制流
通过Zip文件获取，或者通过Jar包获取
将二进制文件存储到数据库中，从数据库中进行获取
使用动态加载的方式获取到二进制数据流

在类加载的第一个阶段，所有的二进制数据都会被加载到内存中，并没有形成实际的可以操作的数据结构。

类的连接阶段

1.验证

在不同JVM上所使用的class文件规范是不一样的，验证就是为了保证这个class文件是符合对应JVM的规范的。如果不符合对应的虚拟机规范的字节流出现的时候就抛出VerifyError的异常。
作为验证来说需要验证的信息有以下的几个

验证文件格式。对于文件来说每个文件都有自己的格式，例如.exe,.txt,.doc.等等都有一个决定文件类型的头信息，对于我们虚拟机需要执行class文件来说也是有头信息的0xCAFEBABE，在Class文件中还包含了主次版本号例如在我们使用高版本的JDK编译完成Class文件之后，使用低版本的JDK去执行，就会出现小版本好不兼容的问题，也就是在类加载验证的时候出现了超过JDK检查范围的情况。
元数据验证，在学习编译原理时候有个概念就是词法分析和语义分析，对于类加载验证来说其实就是JVM对于java语言的本身的一个语法分析和语义分析的过程。通过语法分析和语义分析，了解父类信息，了解final，了解抽象等等信息。
字节码验证，通过语义分析过程之后要对接收到的字节码进行进一步的验证，这个验证就包括了对于Java基本语法的验证，包括对于分支、循环等以及程序计数器的指令执行过程、数据类型转换、是否满桌子happen-before原则等等。
符号引用验证，在类加载结束阶段，就是对于所有的符号引用的验证，也就是说对于public、protected、private等等一些权限的验证，这个也是保证了动作的解析执行顺序，例如会有出现ClassNotFind的异常等等。

当然对于类加载验证来说并不只是做这些工作，对于我们需要加载的Class文件来源是比较广泛的，所以说class的验证也是包含了很多的东西，但是最为主要的就是保证程序运行。

2.准备
当一个类经过验证过程之后，也就是说它符合Java语言规范以及JVM的规范。这样的话它就可以被准备变量的分配对应的虚拟机内存了，当然我们知道在Java中如果你对一个变量没有进行赋值的话，到这一步也会对其进行默认的赋值。
3.解析
经过验证和准备两个阶段之后，对于Java程序所需要的内存结构和需要的数据进行了准备，解析过程就是通过上面两个过程得到的引用进行重新的组装，形成将符号引用换成直接引用的过程。可以使用javap -verbose + class 文件的方式进行查看内容

F:\developersrc\GIT\JavaHighConcurrency\JavaHC\target\classes\com\example\charp09>javap -verbose Singleton.class
Classfile /F:/developersrc/GIT/JavaHighConcurrency/JavaHC/target/classes/com/example/charp09/Singleton.class
  Last modified 2019-5-10; size 1214 bytes
  MD5 checksum 68d4b078c523db7729b46aeeb6cfb2af
  Compiled from "Singleton.java"
public class com.example.charp09.Singleton
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #17.#40        // java/lang/Object."":()V
   #2 = Fieldref           #41.#42        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #43            // 执行初始化方法
   #4 = Methodref          #44.#45        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Fieldref           #10.#46        // com/example/charp09/Singleton.a:I
   #6 = Fieldref           #10.#47        // com/example/charp09/Singleton.b:I
   #7 = String             #48            // 对象实例开始创建
   #8 = Fieldref           #10.#49        // com/example/charp09/Singleton.instance:Lcom/example/charp09/Singleton;
   #9 = String             #50            // 类对象没有被初始化
  #10 = Class              #51            // com/example/charp09/Singleton
  #11 = Methodref          #10.#40        // com/example/charp09/Singleton."":()V
  #12 = String             #52            // 创建对象完成
  #13 = Methodref          #10.#53        // com/example/charp09/Singleton.getInstance:()Lcom/example/charp09/Singleton;
  #14 = Methodref          #44.#54        // java/io/PrintStream.println:(I)V
  #15 = String             #55            // =====通过类名直接调用====
  #16 = String             #56            // 执行了静态代码块
  #17 = Class              #57            // java/lang/Object
  #18 = Utf8               a
  #19 = Utf8               I
  #20 = Utf8               b
  #21 = Utf8               instance
  #22 = Utf8               Lcom/example/charp09/Singleton;
  #23 = Utf8               <init>
  #24 = Utf8               ()V
  #25 = Utf8               Code
  #26 = Utf8               LineNumberTable
  #27 = Utf8               LocalVariableTable
  #28 = Utf8               this
  #29 = Utf8               getInstance
  #30 = Utf8               ()Lcom/example/charp09/Singleton;
  #31 = Utf8               StackMapTable
  #32 = Utf8               main
  #33 = Utf8               ([Ljava/lang/String;)V
  #34 = Utf8               args
  #35 = Utf8               [Ljava/lang/String;
  #36 = Utf8               singleton
  #37 = Utf8               <clinit>
  #38 = Utf8               SourceFile
  #39 = Utf8               Singleton.java
  #40 = NameAndType        #23:#24        // "":()V
  #41 = Class              #58            // java/lang/System
  #42 = NameAndType        #59:#60        // out:Ljava/io/PrintStream;
  #43 = Utf8               执行初始化方法
  #44 = Class              #61            // java/io/PrintStream
  #45 = NameAndType        #62:#63        // println:(Ljava/lang/String;)V
  #46 = NameAndType        #18:#19        // a:I
  #47 = NameAndType        #20:#19        // b:I
  #48 = Utf8               对象实例开始创建
  #49 = NameAndType        #21:#22        // instance:Lcom/example/charp09/Singleton;
  #50 = Utf8               类对象没有被初始化
  #51 = Utf8               com/example/charp09/Singleton
  #52 = Utf8               创建对象完成
  #53 = NameAndType        #29:#30        // getInstance:()Lcom/example/charp09/Singleton;
  #54 = NameAndType        #62:#64        // println:(I)V
  #55 = Utf8               =====通过类名直接调用====
  #56 = Utf8               执行了静态代码块
  #57 = Utf8               java/lang/Object
  #58 = Utf8               java/lang/System
  #59 = Utf8               out
  #60 = Utf8               Ljava/io/PrintStream;
  #61 = Utf8               java/io/PrintStream
  #62 = Utf8               println
  #63 = Utf8               (Ljava/lang/String;)V
  #64 = Utf8               (I)V
{
  public static com.example.charp09.Singleton getInstance();
    descriptor: ()Lcom/example/charp09/Singleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #7                  // String 对象实例开始创建
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: getstatic     #8                  // Field instance:Lcom/example/charp09/Singleton;
        11: ifnull        32
        14: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        17: ldc           #9                  // String 类对象没有被初始化
        19: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        22: new           #10                 // class com/example/charp09/Singleton
        25: dup
        26: invokespecial #11                 // Method "":()V
        29: putstatic     #8                  // Field instance:Lcom/example/charp09/Singleton;
        32: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        35: ldc           #12                 // String 创建对象完成
        37: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        40: getstatic     #8                  // Field instance:Lcom/example/charp09/Singleton;
        43: areturn
      LineNumberTable:
        line 30: 0
        line 31: 8
        line 32: 14
        line 33: 22
        line 35: 32
        line 36: 40
      StackMapTable: number_of_entries = 1
        frame_type = 32 /* same */

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: invokestatic  #13                 // Method getInstance:()Lcom/example/charp09/Singleton;
         3: astore_1
         4: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: aload_1
         8: pop
         9: getstatic     #5                  // Field a:I
        12: invokevirtual #14                 // Method java/io/PrintStream.println:(I)V
        15: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        18: aload_1
        19: pop
        20: getstatic     #6                  // Field b:I
        23: invokevirtual #14                 // Method java/io/PrintStream.println:(I)V
        26: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        29: ldc           #15                 // String =====通过类名直接调用====
        31: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        34: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        37: getstatic     #5                  // Field a:I
        40: invokevirtual #14                 // Method java/io/PrintStream.println:(I)V
        43: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
        46: getstatic     #6                  // Field b:I
        49: invokevirtual #14                 // Method java/io/PrintStream.println:(I)V
        52: return
      LineNumberTable:
        line 40: 0
        line 41: 4
        line 42: 15
        line 43: 26
        line 44: 34
        line 45: 43
        line 46: 52
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      53     0  args   [Ljava/lang/String;
            4      49     1 singleton   Lcom/example/charp09/Singleton;

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #16                 // String 执行了静态代码块
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: iconst_1
         9: putstatic     #5                  // Field a:I
        12: return
      LineNumberTable:
        line 13: 0
        line 16: 8
}
SourceFile: "Singleton.java"

通过上面分析我们可以看到，其实在JVM中虚拟机规范规定了一些符号引用的操作指令，anewarray、checkcast、getfield、getstatic、instanceof、invokeinterface、invokespecial、invokerstatic、invokevirtual、multianewarray、new、putfield、putstatic等。这些都是操作符号引用的命令，在执行符号引用的字节码指令之前，必须要对所有的符号引用提前解析。解析的过程主要针对类接口、字段、类方法、和接口方法四种类型的数据进行操作。分别使用的常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、Constant_Methodref_info和Constant_InterfaceMethodred_info这四中类型的常量。

接口类解析
也就是对于类的解析，各种类结构的解析，包括数组、集合等数据结构，在内存中使用合适的方式进行内存的分配
字段解析
在接口或者类中定义了很多的字段，当需要解析对应的类或者接口的时候对应的字段不存在就会出现异常。例如没有找到对应的属性异常
类方法解析
类方法可以直接使用类对象进行调用，完成对于类的解析的时候就已经完成了解析。
接口方法解析
与类方法不同的是接口不能做对象的实例化操作，所以只能等到对应的类实现进行解析的时候才会被解析。同样也会有类方法所出现的问题。

类的初始化阶段

经过的千辛万苦终于到了类的初始化阶段，也就是我们上面抛出的第一个问题，为什么四个结果是不一样的。在这之前首先要澄清一个事实，就是这里所说的初始化方法和构造函数是有所不同的，在Java虚拟机中会保证父类的init方法是最先执行，所以说父类中的静态变量最先被赋值。但是这个与双亲委派机制还是有点不一样的。双亲委派机制是对于类加载来说的，与类的初始化并没有关系，下面的例子才是与类的初始化相关的，希望不要混淆两个概念。例如

public class Test {

    //在父类中与静态变量value
    static class Parent{
        static  int value = 10;
        static {
            value = 20;
        }
    }

    static class Child extends Parent{
        static int i = value;
    }

    public static void main(String[] args) {
        System.out.println(Child.i);
    }
}

使用javap -verbose Test.class命令

F:\developersrc\GIT\JavaHighConcurrency\JavaHC\target\classes\com\example\charp09>javap -verbose Test.class
Classfile /F:/developersrc/GIT/JavaHighConcurrency/JavaHC/target/classes/com/example/charp09/Test.class
  Last modified 2019-5-11; size 669 bytes
  MD5 checksum 8f63ac13577d305756bdf9898531cf75
  Compiled from "Test.java"
public class com.example.charp09.Test
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #6.#25         // java/lang/Object."":()V
   #2 = Fieldref           #26.#27        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = Fieldref           #7.#28         // com/example/charp09/Test$Child.i:I
   #4 = Methodref          #29.#30        // java/io/PrintStream.println:(I)V
   #5 = Class              #31            // com/example/charp09/Test
   #6 = Class              #32            // java/lang/Object
   #7 = Class              #33            // com/example/charp09/Test$Child
   #8 = Utf8               Child
   #9 = Utf8               InnerClasses
  #10 = Class              #34            // com/example/charp09/Test$Parent
  #11 = Utf8               Parent
  #12 = Utf8               <init>
  #13 = Utf8               ()V
  #14 = Utf8               Code
  #15 = Utf8               LineNumberTable
  #16 = Utf8               LocalVariableTable
  #17 = Utf8               this
  #18 = Utf8               Lcom/example/charp09/Test;
  #19 = Utf8               main
  #20 = Utf8               ([Ljava/lang/String;)V
  #21 = Utf8               args
  #22 = Utf8               [Ljava/lang/String;
  #23 = Utf8               SourceFile
  #24 = Utf8               Test.java
  #25 = NameAndType        #12:#13        // "":()V
  #26 = Class              #35            // java/lang/System
  #27 = NameAndType        #36:#37        // out:Ljava/io/PrintStream;
  #28 = NameAndType        #38:#39        // i:I
  #29 = Class              #40            // java/io/PrintStream
  #30 = NameAndType        #41:#42        // println:(I)V
  #31 = Utf8               com/example/charp09/Test
  #32 = Utf8               java/lang/Object
  #33 = Utf8               com/example/charp09/Test$Child
  #34 = Utf8               com/example/charp09/Test$Parent
  #35 = Utf8               java/lang/System
  #36 = Utf8               out
  #37 = Utf8               Ljava/io/PrintStream;
  #38 = Utf8               i
  #39 = Utf8               I
  #40 = Utf8               java/io/PrintStream
  #41 = Utf8               println
  #42 = Utf8               (I)V
{
  public com.example.charp09.Test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."":()V
         4: return
      LineNumberTable:
        line 10: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/example/charp09/Test;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: getstatic     #3                  // Field com/example/charp09/Test$Child.i:I
         6: invokevirtual #4                  // Method java/io/PrintStream.println:(I)V
         9: return
      LineNumberTable:
        line 25: 0
        line 26: 9
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      10     0  args   [Ljava/lang/String;
}
SourceFile: "Test.java"
InnerClasses:
     static #8= #7 of #5; //Child=class com/example/charp09/Test$Child of class com/example/charp09/Test
     static #11= #10 of #5; //Parent=class com/example/charp09/Test$Parent of class com/example/charp09/Test

特别注意者几行名

#1 = Methodref          #6.#25         // java/lang/Object."":()V
#6 = Class              #32            // java/lang/Object
#25 = NameAndType        #12:#13        // "":()V
#12 = Utf8               <init>
#13 = Utf8               ()V

实际上在类加载过程中Java虚拟机会自动调用一个初始化的方法
分析其子类

F:\developersrc\GIT\JavaHighConcurrency\JavaHC\target\classes\com\example\charp09>javap -verbose Test$Child.class
Classfile /F:/developersrc/GIT/JavaHighConcurrency/JavaHC/target/classes/com/example/charp09/Test$Child.class
  Last modified 2019-5-11; size 490 bytes
  MD5 checksum ce5998b840029681a2c3a6ff986350cb
  Compiled from "Test.java"
class com.example.charp09.Test$Child extends com.example.charp09.Test$Parent
  minor version: 0
  major version: 52
  flags: ACC_SUPER
Constant pool:
   #1 = Methodref          #5.#20         // com/example/charp09/Test$Parent."":()V
   #2 = Fieldref           #4.#21         // com/example/charp09/Test$Child.value:I
   #3 = Fieldref           #4.#22         // com/example/charp09/Test$Child.i:I
   #4 = Class              #24            // com/example/charp09/Test$Child
   #5 = Class              #25            // com/example/charp09/Test$Parent
   #6 = Utf8               i
   #7 = Utf8               I
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               Child
  #15 = Utf8               InnerClasses
  #16 = Utf8               Lcom/example/charp09/Test$Child;
  #17 = Utf8               <clinit>
  #18 = Utf8               SourceFile
  #19 = Utf8               Test.java
  #20 = NameAndType        #8:#9          // "":()V
  #21 = NameAndType        #27:#7         // value:I
  #22 = NameAndType        #6:#7          // i:I
  #23 = Class              #28            // com/example/charp09/Test
  #24 = Utf8               com/example/charp09/Test$Child
  #25 = Utf8               com/example/charp09/Test$Parent
  #26 = Utf8               Parent
  #27 = Utf8               value
  #28 = Utf8               com/example/charp09/Test
{
  static int i;
    descriptor: I
    flags: ACC_STATIC

  com.example.charp09.Test$Child();
    descriptor: ()V
    flags:
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method com/example/charp09/Test$Parent."":()V
         4: return
      LineNumberTable:
        line 20: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/example/charp09/Test$Child;

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: getstatic     #2                  // Field value:I
         3: putstatic     #3                  // Field i:I
         6: return
      LineNumberTable:
        line 21: 0
}
SourceFile: "Test.java"
InnerClasses:
     static #14= #4 of #23; //Child=class com/example/charp09/Test$Child of class com/example/charp09/Test
     static #26= #5 of #23; //Parent=class com/example/charp09/Test$Parent of class com/example/charp09/Test

注意以下的命令的调用

#1 = Methodref          #5.#20         // com/example/charp09/Test$Parent."":()V
#5 = Class              #25            // com/example/charp09/Test$Parent
#25 = Utf8               com/example/charp09/Test$Parent
#20 = NameAndType        #8:#9          // "":()V
#8 = Utf8               <init>
#9 = Utf8               ()V

从这里可以看出，子类在调用的过程中是父类的初始化方法先得到了执行，所以说调用的i的值是20而不是子类的10。但是这个过程中并不是所有的class都会被创建init方法，例如一个类中既没有静态代码块，也没有静态变量，那么就没有初始化的必要了，在接口中也是一样的，对于一个接口来说本身就不支持这样的操作所以说只有在被继承并且有变量被初始的时候才会生成init方法。
对于init方法来说在虚拟机中是真是存在的。多个线程对于同一个对象使用init方法的时候会不会引起线程安全问题。

public class Init {
    static {
        try{
            System.out.println("The init static code block will be invoke.");
            TimeUnit.MINUTES.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        IntStream.range(0,5).forEach(i->new Thread(Init::new));
    }
}

上面代码中运行结果显示同一时间内只有一个线程执行了静态代码块中的内容，并且保证了静态代码块只会被执行一次，也就是说在多线程中是单实例的。保证了多线程同步操作。

结果不一样实现的分析

第一种方式实现分析

public class TestSingleton {

        private static int a = 0;

        private static int b ;

        private static TestSingleton instance = new TestSingleton();

        private TestSingleton(){
            a++;
            b++;
        }

        public static TestSingleton getInstance(){
            return instance;
        }

        public static void main(String[] args) {
            TestSingleton singleton = TestSingleton.getInstance();
            System.out.println(singleton.a);
            System.out.println(singleton.b);
        }
}

F:\developersrc\GIT\JavaHighConcurrency\JavaHC\target\classes\com\example\charp09>javap -verbose TestSingleton.class
Classfile /F:/developersrc/GIT/JavaHighConcurrency/JavaHC/target/classes/com/example/charp09/TestSingleton.class
  Last modified 2019-5-11; size 880 bytes
  MD5 checksum 3a736ae3e2f234962fc4d01bd06a0ca5
  Compiled from "TestSingleton.java"
public class com.example.charp09.TestSingleton
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #10.#32        // java/lang/Object."":()V
   #2 = Fieldref           #8.#33         // com/example/charp09/TestSingleton.a:I
   #3 = Fieldref           #8.#34         // com/example/charp09/TestSingleton.b:I
   #4 = Fieldref           #8.#35         // com/example/charp09/TestSingleton.instance:Lcom/example/charp09/TestSingleton;
   #5 = Methodref          #8.#36         // com/example/charp09/TestSingleton.getInstance:()Lcom/example/charp09/TestSingleton;
   #6 = Fieldref           #37.#38        // java/lang/System.out:Ljava/io/PrintStream;
   #7 = Methodref          #39.#40        // java/io/PrintStream.println:(I)V
   #8 = Class              #41            // com/example/charp09/TestSingleton
   #9 = Methodref          #8.#32         // com/example/charp09/TestSingleton."":()V
  #10 = Class              #42            // java/lang/Object
  #11 = Utf8               a
  #12 = Utf8               I
  #13 = Utf8               b
  #14 = Utf8               instance
  #15 = Utf8               Lcom/example/charp09/TestSingleton;
  #16 = Utf8               <init>
  #17 = Utf8               ()V
  #18 = Utf8               Code
  #19 = Utf8               LineNumberTable
  #20 = Utf8               LocalVariableTable
  #21 = Utf8               this
  #22 = Utf8               getInstance
  #23 = Utf8               ()Lcom/example/charp09/TestSingleton;
  #24 = Utf8               main
  #25 = Utf8               ([Ljava/lang/String;)V
  #26 = Utf8               args
  #27 = Utf8               [Ljava/lang/String;
  #28 = Utf8               singleton
  #29 = Utf8               <clinit>
  #30 = Utf8               SourceFile
  #31 = Utf8               TestSingleton.java
  #32 = NameAndType        #16:#17        // "":()V
  #33 = NameAndType        #11:#12        // a:I
  #34 = NameAndType        #13:#12        // b:I
  #35 = NameAndType        #14:#15        // instance:Lcom/example/charp09/TestSingleton;
  #36 = NameAndType        #22:#23        // getInstance:()Lcom/example/charp09/TestSingleton;
  #37 = Class              #43            // java/lang/System
  #38 = NameAndType        #44:#45        // out:Ljava/io/PrintStream;
  #39 = Class              #46            // java/io/PrintStream
  #40 = NameAndType        #47:#48        // println:(I)V
  #41 = Utf8               com/example/charp09/TestSingleton
  #42 = Utf8               java/lang/Object
  #43 = Utf8               java/lang/System
  #44 = Utf8               out
  #45 = Utf8               Ljava/io/PrintStream;
  #46 = Utf8               java/io/PrintStream
  #47 = Utf8               println
  #48 = Utf8               (I)V
{
  public static com.example.charp09.TestSingleton getInstance();
    descriptor: ()Lcom/example/charp09/TestSingleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: getstatic     #4                  // Field instance:Lcom/example/charp09/TestSingleton;
         3: areturn
      LineNumberTable:
        line 24: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: invokestatic  #5                  // Method getInstance:()Lcom/example/charp09/TestSingleton;
         3: astore_1
         4: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: aload_1
         8: pop
         9: getstatic     #2                  // Field a:I
        12: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        15: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        18: aload_1
        19: pop
        20: getstatic     #3                  // Field b:I
        23: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        26: return
      LineNumberTable:
        line 28: 0
        line 29: 4
        line 30: 15
        line 31: 26
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      27     0  args   [Ljava/lang/String;
            4      23     1 singleton   Lcom/example/charp09/TestSingleton;

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: iconst_0
         1: putstatic     #2                  // Field a:I
         4: new           #8                  // class com/example/charp09/TestSingleton
         7: dup
         8: invokespecial #9                  // Method "":()V
        11: putstatic     #4                  // Field instance:Lcom/example/charp09/TestSingleton;
        14: return
      LineNumberTable:
        line 12: 0
        line 16: 4
}
SourceFile: "TestSingleton.java"

第二种方式的实现分析

public class TestSingleton {

    private static TestSingleton instance = new TestSingleton();

    private static int a = 0;

    private static int b;


    private TestSingleton() {
        a++;
        b++;
    }

    public static TestSingleton getInstance() {
        return instance;
    }

    public static void main(String[] args) {
        TestSingleton singleton = TestSingleton.getInstance();
        System.out.println(singleton.a);
        System.out.println(singleton.b);
    }
}

F:\developersrc\GIT\JavaHighConcurrency\JavaHC\target\classes\com\example\charp09>javap -verbose TestSingleton.class
Classfile /F:/developersrc/GIT/JavaHighConcurrency/JavaHC/target/classes/com/example/charp09/TestSingleton.class
  Last modified 2019-5-11; size 880 bytes
  MD5 checksum ee8a547c6b9237352c3131fc4c777a4e
  Compiled from "TestSingleton.java"
public class com.example.charp09.TestSingleton
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #10.#32        // java/lang/Object."":()V
   #2 = Fieldref           #8.#33         // com/example/charp09/TestSingleton.a:I
   #3 = Fieldref           #8.#34         // com/example/charp09/TestSingleton.b:I
   #4 = Fieldref           #8.#35         // com/example/charp09/TestSingleton.instance:Lcom/example/charp09/TestSingleton;
   #5 = Methodref          #8.#36         // com/example/charp09/TestSingleton.getInstance:()Lcom/example/charp09/TestSingleton;
   #6 = Fieldref           #37.#38        // java/lang/System.out:Ljava/io/PrintStream;
   #7 = Methodref          #39.#40        // java/io/PrintStream.println:(I)V
   #8 = Class              #41            // com/example/charp09/TestSingleton
   #9 = Methodref          #8.#32         // com/example/charp09/TestSingleton."":()V
  #10 = Class              #42            // java/lang/Object
  #11 = Utf8               instance
  #12 = Utf8               Lcom/example/charp09/TestSingleton;
  #13 = Utf8               a
  #14 = Utf8               I
  #15 = Utf8               b
  #16 = Utf8               <init>
  #17 = Utf8               ()V
  #18 = Utf8               Code
  #19 = Utf8               LineNumberTable
  #20 = Utf8               LocalVariableTable
  #21 = Utf8               this
  #22 = Utf8               getInstance
  #23 = Utf8               ()Lcom/example/charp09/TestSingleton;
  #24 = Utf8               main
  #25 = Utf8               ([Ljava/lang/String;)V
  #26 = Utf8               args
  #27 = Utf8               [Ljava/lang/String;
  #28 = Utf8               singleton
  #29 = Utf8               <clinit>
  #30 = Utf8               SourceFile
  #31 = Utf8               TestSingleton.java
  #32 = NameAndType        #16:#17        // "":()V
  #33 = NameAndType        #13:#14        // a:I
  #34 = NameAndType        #15:#14        // b:I
  #35 = NameAndType        #11:#12        // instance:Lcom/example/charp09/TestSingleton;
  #36 = NameAndType        #22:#23        // getInstance:()Lcom/example/charp09/TestSingleton;
  #37 = Class              #43            // java/lang/System
  #38 = NameAndType        #44:#45        // out:Ljava/io/PrintStream;
  #39 = Class              #46            // java/io/PrintStream
  #40 = NameAndType        #47:#48        // println:(I)V
  #41 = Utf8               com/example/charp09/TestSingleton
  #42 = Utf8               java/lang/Object
  #43 = Utf8               java/lang/System
  #44 = Utf8               out
  #45 = Utf8               Ljava/io/PrintStream;
  #46 = Utf8               java/io/PrintStream
  #47 = Utf8               println
  #48 = Utf8               (I)V
{
  public static com.example.charp09.TestSingleton getInstance();
    descriptor: ()Lcom/example/charp09/TestSingleton;
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: getstatic     #4                  // Field instance:Lcom/example/charp09/TestSingleton;
         3: areturn
      LineNumberTable:
        line 25: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: invokestatic  #5                  // Method getInstance:()Lcom/example/charp09/TestSingleton;
         3: astore_1
         4: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
         7: aload_1
         8: pop
         9: getstatic     #2                  // Field a:I
        12: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        15: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
        18: aload_1
        19: pop
        20: getstatic     #3                  // Field b:I
        23: invokevirtual #7                  // Method java/io/PrintStream.println:(I)V
        26: return
      LineNumberTable:
        line 29: 0
        line 30: 4
        line 31: 15
        line 32: 26
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      27     0  args   [Ljava/lang/String;
            4      23     1 singleton   Lcom/example/charp09/TestSingleton;

  static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=2, locals=0, args_size=0
         0: new           #8                  // class com/example/charp09/TestSingleton
         3: dup
         4: invokespecial #9                  // Method "":()V
         7: putstatic     #4                  // Field instance:Lcom/example/charp09/TestSingleton;
        10: iconst_0
        11: putstatic     #2                  // Field a:I
        14: return
      LineNumberTable:
        line 12: 0
        line 14: 10
}
SourceFile: "TestSingleton.java"

通过对于上面两个例子的查看，可以看到,两种方式调用instance的位置和时机不同，导致了两次的结果不一样。

实际上两段代码的不同也只不过是调用 private static TestSingleton instance = new TestSingleton(); 方法的位置不同。但是结果相差还是很大的。

总结

结合实际的例子通过反编译查看class文件的方式了解了整个Java类加载过程中的细节性的问题，当然，在整个分析过程中都是围绕着类加载的三个阶段锁展开的。类加载的整个过程包括三个大的阶段和三个小阶段，三个大阶段包括加载连接初始化，小阶段包括，验证准备加解析。了解者三个过程，对于以后的面试以及工作会有很大的帮助。

你可能感兴趣的:(高并发,Java高并发,java,类加载)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
华为云分布式缓存服务DCS 8月新特性发布华为云PaaS服务小智华为云分布式缓存
分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
Spring中@Value注解，需要注意的地方无量 spring bean @Value xml
Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 1、在applicationContext.xml文件(或引用文件中)中配置properties文件 <bean id="appProperty" class="org.springframework.beans.fac
mongoDB 分片开窍的石头 mongodb
mongoDB的分片。要mongos查询数据时候先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。第一步启动两台以上的mongo服务 &nb
OVER(PARTITION BY)函数用法 0624chenhong oracle
这篇写得很好，引自 http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html OVER(PARTITION BY)函数用法 2010年10月26日 OVER(PARTITION BY)函数介绍开窗函数 &nb
Android开发中，ADB server didn't ACK 解决方法一炮送你回车库 Android开发
首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 &nb
canvas中的像素绘制问题换个号韩国红果果 JavaScript canvas
pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 2.如果绘制点为一个像素的
编码乱码问题灵静志远 java jvm jsp 编码
1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 3、getBytes()、getByte
java 求几个月后的日期 darkranger calendar getinstance
Date plandate = planDate.toDate(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); Calendar cal = Calendar.getInstance(); cal.setTime(plandate); // 取得三个月后时间 cal.add(Calendar.M
数据库设计的三大范式（通俗易懂） aijuans 数据库复习
关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
想学工作流怎么入手 atongyeye jbpm
工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。系统学习工作流，很重要的一本书《JBPM工作流开发指南》。本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 1 首先要
Context和SQLiteOpenHelper创建数据库百合不是茶 android Context创建数据库
一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 一:SQLiteOpenHelper创建数据库: 1,SQLi
浅谈group by和distinct bijian1013 oracle 数据库 group by distinct
group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。譬如：统计每id数并且只显示数大于3 select id ,count(id) from ta
vi opertion 征客丶 mac opration vi
进入 command mode （命令行模式）按 esc 键再按 shift + 冒号注：以下命令中带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】一、文件操作 1.1、强制退出不保存 $ q! 1.2、保存 $ w 1.3、保存并退出 $ wq 1.4、刷新或重新加载已打开的文件 $ e 二、光标移动 2.1、跳到指定行数字
【Spark十四】深入Spark RDD第三部分RDD基本API bit1129 spark
对于K/V类型的RDD,如下操作是什么含义？ val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5)) rdd.reduceByKey(_+_).collect reduceByKey在这里的操作，是把
java类加载机制 BlueSkator java 虚拟机
java类加载机制 1.java类加载器的树状结构引导类加载器 ^ | 扩展类加载器 ^ | 系统类加载器 java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。虚拟机区分一个Cla
动态添加文本框 BreakingBad 文本框
<script> var num=1; function AddInput() { var str=""; str+="<input
读《研磨设计模式》-代码笔记-单例模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ public class Singleton { } /* * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题 */ class LazySingleton
iOS应用打包发布常见问题 chenhbc ios iOS发布 iOS上传 iOS打包
这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
工作流复杂拓扑结构处理新思路 comsci 设计模式工作算法企业应用 OO
我们走的设计路线和国外的产品不太一样，不一样在哪里呢？国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
oracle 11g新特性Flashback data archive daizj oracle
1. 什么是flashback data archive Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。
多叉树:2-3-4树 dieslrae 树
平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 1、有一个数据项的节点总是有2个子节点(称为2-节点) 2、有两个数据项的节点总是有3个子节点(称为3-节
C语言学习七动态分配 malloc的使用 dcj3sjt126com c language malloc
/* 2013年3月15日15:16:24 malloc 就memory(内存) allocate(分配)的缩写本程序没有实际含义，只是理解使用 */ # include <stdio.h> # include <malloc.h> int main(void) { int i = 5; //分配了4个字节静态分配 int * p
Objective-C编码规范[译] dcj3sjt126com 代码规范
原文链接 : The official raywenderlich.com Objective-C style guide 原文作者 : raywenderlich.com Team 译文出自 : raywenderlich.com Objective-C编码规范译者 : Sam Lau
0.性能优化-目录 frank1234 性能优化
从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。主要内容包括：一、性能测试指标吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 http://frank1234.iteye.com/blog/2180305 二、性能测试策略生产环境相同基准测试预热等 htt
Java父类取得子类传递的泛型参数Class类型 happyqing java 泛型父类子类 Class
import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import org.junit.Test; abstract class BaseDao<T> { public void getType() { //Class<E> clazz =
跟我学SpringMVC目录汇总贴、PDF下载、源码下载 jinnianshilongnian springMVC
----广告-------------------------------------------------------------- 网站核心商详页开发掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架；掌握数据库技术，表设计和索引优化，分库分表/读写分离；了解缓存技术，熟练使用如Redis/Memcached等主流技术；了解Ngin
the HTTP rewrite module requires the PCRE library 流浪鱼 rewrite
./configure: error: the HTTP rewrite module requires the PCRE library. 模块依赖性Nginx需要依赖下面3个包 1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 3. s
第12章 Ajax（中） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Optimize query with Query Stripping in Web Intelligence blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence and a very straightfoward video http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
Java开发者写SQL时常犯的10个错误 tomcat_oracle java sql
1、不用PreparedStatements 　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：　　他们对PreparedStatements不了解　　他们认为使用PreparedStatements太慢了　　他们认为写Prepar
世纪互联与结盟有感阿尔萨斯
10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟