JVM學習筆記（二）(類加載與字節碼技術)，看這篇文章就夠了

原創 Kun哥666 2020-05-22 05:04

1_類文件結構
在這裏插入圖片描述
一個簡單的 HelloWorld.java
在這裏插入圖片描述
執行 javac -parameters -d . HellowWorld.java
編譯爲 HelloWorld.class 後是這個樣子的：
在這裏插入圖片描述
根據 JVM 規範，類文件結構如下：
在這裏插入圖片描述
01_1 魔數
在這裏插入圖片描述
01_2 版本
在這裏插入圖片描述
01_3 常量池
在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述
01_4 訪問標識和繼承信息
在這裏插入圖片描述在這裏插入圖片描述
01_5 Field信息
在這裏插入圖片描述01_6 Method信息
在這裏插入圖片描述

2_ 字節碼指令
01_ javap 工具
自己分析類文件結構太麻煩了，Oracle 提供了 javap 工具來反編譯 class 文件:javap -v name.class

02_ 圖解方法的執行流程
1）原始 java 代碼

/**
 * 演示 字節碼指令 和 操作數棧、常量池的關係
 */
public class Demo3_1 {
    public static void main(String[] args) {
        int a = 10;
        int b = Short.MAX_VALUE + 1;
        int c = a + b;
        System.out.println(c);
    }
}

2）編譯後的字節碼文件
在這裏插入圖片描述
3）常量池載入運行時常量池
在這裏插入圖片描述
4）方法字節碼載入方法區
在這裏插入圖片描述
5）main 線程開始運行，分配棧幀內存
（stack=2，locals=4）=>（表示棧的高度爲2，局部變量表的長度大小爲4）
在這裏插入圖片描述
6）執行引擎開始執行字節碼
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述在這裏插入圖片描述
在這裏插入圖片描述
istore_2
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
iload_2在這裏插入圖片描述
在這裏插入圖片描述
istore_3
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
2.4 練習 - 分析 i++
目的：從字節碼角度分析 a++ 相關題目
源碼：

package cn.itcast.jvm.t3.bytecode;

/**
 * 從字節碼角度分析　a++  相關題目
 */
public class Demo3_2 {
    public static void main(String[] args) {
        int a = 10;
        int b = a++ + ++a + a--;
        System.out.println(a);
        System.out.println(b);
    }
}

字節碼：在這裏插入圖片描述
在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述
在這裏插入圖片描述在這裏插入圖片描述2.5 條件判斷指令在這裏插入圖片描述在這裏插入圖片描述字節碼：

	1: istore_1 
	2: iload_1 
	3: ifne 12 
	6: bipush 10
	8: istore_1
	9: goto 15 
	12: bipush 20 
	14: istore_1 
	15: return

以上比較指令中沒有 long，float，double 的比較，那麼它們要比較怎麼辦？參考 https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.lcmp

2.6 循環控制指令（for循環和while循環一樣）
在這裏插入圖片描述
2.7 練習 - 判斷結果
在這裏插入圖片描述
2.8 構造方法
在這裏插入圖片描述
2） ()V

package cn.itcast.jvm.t3.bytecode;
public class Demo3_8_2 {

    private String a = "s1";

    {
        b = 20;
    }

    private int b = 10;

    {
        a = "s2";
    }

    public Demo3_8_2(String a, int b) {
        this.a = a;
        this.b = b;
    }

    public static void main(String[] args) {
        Demo3_8_2 d = new Demo3_8_2("s3", 30);
        System.out.println(d.a);
        System.out.println(d.b);
    }
}

編譯器會按從上至下的順序，收集所有 {} 代碼塊和成員變量賦值的代碼，形成新的構造方法，但原始構造方法內的代碼總是在最後
在這裏插入圖片描述
2.9 方法調用
看一下幾種不同的方法調用對應的字節碼指令：

package cn.itcast.jvm.t3.bytecode;

public class Demo3_9 {
    public Demo3_9() { }

    private void test1() { }

    private final void test2() { }

    public void test3() { }

    public static void test4() { }

    @Override
    public String toString() {
        return super.toString();
    }

    public static void main(String[] args) {
        Demo3_9 d = new Demo3_9();
        d.test1();
        d.test2();
        d.test3();
        d.test4();
        Demo3_9.test4();
        d.toString();
    }
}
```![在這裏插入圖片描述](https://img-blog.csdnimg.cn/20200518202153189.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3OTg5NzM4,size_16,color_FFFFFF,t_70)
2.10 多態的原理

```java
package cn.itcast.jvm.t3.bytecode;
import java.io.IOException;

/**
 * 演示多態原理，注意加上下面的 JVM 參數，禁用指針壓縮
 * -XX:-UseCompressedOops -XX:-UseCompressedClassPointers
 */
public class Demo3_10 {

    public static void test(Animal animal) {
        animal.eat();
        System.out.println(animal.toString());
    }

    public static void main(String[] args) throws IOException {
        test(new Cat());
        test(new Dog());
        System.in.read();
    }
}

abstract class Animal {
    public abstract void eat();

    @Override
    public String toString() {
        return "我是" + this.getClass().getSimpleName();
    }
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("啃骨頭");
    }
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("吃魚");
    }
}

在這裏插入圖片描述在這裏插入圖片描述
在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述2.11 異常處理
try-catch

package cn.itcast.jvm.t3.bytecode;

public class Demo3_11_1 {

    public static void main(String[] args) {
        int i = 0;
        try {
            i = 10;
            
        } catch (Exception e) {
            i = 20;
        }
    }
}

在這裏插入圖片描述
在這裏插入圖片描述
在這裏插入圖片描述
javac -g Demo3_11_2.java，
javap -v Demo3_11_2.class

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=3, args_size=1
         0: iconst_0
         1: istore_1
         2: bipush        10
         4: istore_1
         5: goto          26
         8: astore_2
         9: bipush        30
        11: istore_1
        12: goto          26
        15: astore_2
        16: bipush        40
        18: istore_1
        19: goto          26
        22: astore_2
        23: bipush        50
        25: istore_1
        26: return
      Exception table:
         from    to  target type
             2     5     8   Class java/lang/ArithmeticException
             2     5    15   Class java/lang/NullPointerException
             2     5    22   Class java/lang/Exception
      LineNumberTable:
        line 6: 0
        line 8: 2
        line 15: 5
        line 9: 8
        line 10: 9
        line 15: 12
        line 11: 15
        line 12: 16
        line 15: 19
        line 13: 22
        line 14: 23
        line 16: 26
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            9       3     2     e   Ljava/lang/ArithmeticException;
           16       3     2     e   Ljava/lang/NullPointerException;
           23       3     2     e   Ljava/lang/Exception;
            0      27     0  args   [Ljava/lang/String;
            2      25     1     i   I

● 因爲異常出現時，只能進入 Exception table 中一個分支，所以局部變量表 slot 2 位置被共用

multi-catch 的情況

public class Demo3_11_3 {

    public static void main(String[] args) {
        try {
            Method test = Demo3_11_3.class.getMethod("test");
            test.invoke(null);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void test() {
        System.out.println("ok");
    }
}

字節碼：

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=2, args_size=1
         0: ldc           #2                  // class cn/itcast/jvm/t3/bytecode/Demo3_11_3
         2: ldc           #3                  // String test
         4: iconst_0
         5: anewarray     #4                  // class java/lang/Class
         8: invokevirtual #5                  // Method java/lang/Class.getMethod:(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;
        11: astore_1
        12: aload_1
        13: aconst_null
        14: iconst_0
        15: anewarray     #6                  // class java/lang/Object
        18: invokevirtual #7                  // Method java/lang/reflect/Method.invoke:(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;
        21: pop
        22: goto          30
        25: astore_1
        26: aload_1
        27: invokevirtual #11                 // Method java/lang/ReflectiveOperationException.printStackTrace:()V
        30: return
      Exception table:
         from    to  target type
             0    22    25   Class java/lang/NoSuchMethodException
             0    22    25   Class java/lang/IllegalAccessException
             0    22    25   Class java/lang/reflect/InvocationTargetException
      LineNumberTable:
        line 10: 0
        line 11: 12
        line 14: 22
        line 12: 25
        line 13: 26
        line 15: 30
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           12      10     1  test   Ljava/lang/reflect/Method;
           26       4     1     e   Ljava/lang/ReflectiveOperationException;
            0      31     0  args   [Ljava/lang/String;

finally

package cn.itcast.jvm.t3.bytecode;

public class Demo3_11_4 {

    public static void main(String[] args) {
        int i = 0;
        try {
            i = 10;
        } catch (Exception e) {
            i = 20;
        } finally {
            i = 30;
        }
    }
}

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=4, args_size=1
         0: iconst_0
         1: istore_1
         2: bipush        10
         4: istore_1
         5: bipush        30
         7: istore_1
         8: goto          27
        11: astore_2
        12: bipush        20
        14: istore_1
        15: bipush        30
        17: istore_1
        18: goto          27
        21: astore_3
        22: bipush        30
        24: istore_1
        25: aload_3
        26: athrow
        27: return
      Exception table:
         from    to  target type
             2     5    11   Class java/lang/Exception
             2     5    21   any
            11    15    21   any
      LineNumberTable:
        line 6: 0
        line 8: 2
        line 12: 5
        line 13: 8
        line 9: 11
        line 10: 12
        line 12: 15
        line 13: 18
        line 12: 21
        line 14: 27
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
           12       3     2     e   Ljava/lang/Exception;
            0      28     0  args   [Ljava/lang/String;
            2      26     1     i   I

可以看到 finally 中的代碼被複制了 3 份，分別放入 try 流程，catch 流程以及 catch 剩餘的異常類型流程，保證finally裏面的內容最後執行。

2.12 練習 - finally 面試題

finally 出現了 return
先問問自己，下面的題目輸出什麼？

public class Demo3_12_2 {
    public static void main(String[] args) {
        int result = test();
        System.out.println(result);
    }

    public static int test() {
   
        try {
            return 10;
        } finally {
            return 20;
        }
    }
}

 public static int test();
    descriptor: ()I
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=2, args_size=0
         0: bipush        10
         2: istore_0
         3: bipush        20
         5: ireturn
         6: astore_1
         7: bipush        20
         9: ireturn
      Exception table:
         from    to  target type
             0     3     6   any
      LineNumberTable:
        line 12: 0
        line 14: 3

finally 對返回值影響
同樣問問自己，下面的題目輸出什麼？

public class Demo3_12_2 {
    public static void main(String[] args) {
        int result = test();
        System.out.println(result);
    }

    public static int test() {
        int i = 10;
        try {
            return i;
        } finally {
            i = 20;
        }
    }
}

 public static int test();
    descriptor: ()I
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=3, args_size=0
         0: bipush        10   //10放入棧頂
         2: istore_0     // 10 -> i
         3: iload_0      // <- i(10)
         4: istore_1     // 10 -> slot 1，暫存至 slot 1，目的是爲了固定返回值
         5: bipush        20   // <- 20 放入棧頂
         7: istore_0    // 20 -> i
         8: iload_1     // <- slot 1(10) 載入 slot 1 暫存的值
         9: ireturn         // 返回棧頂的 int(10)
        10: astore_2
        11: bipush        20
        13: istore_0
        14: aload_2
        15: athrow
      Exception table:
         from    to  target type
             3     5    10   any
      LineNumberTable:
        line 10: 0
        line 12: 3
        line 14: 5
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            3      13     0     i   I

2.13 synchronized

public class Demo3_13 {

    public static void main(String[] args) {
        Object lock = new Object();
        synchronized (lock) {
            System.out.println("ok");
        }
    }
}

 public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #2                  // class java/lang/Object
         3: dup
         4: invokespecial #1                  // Method java/lang/Object."<init>":()V
         7: astore_1                         // lock引用 -> lock**
         8: aload_1							// <- lock （synchronized開始）
         9: dup
        10: astore_2						// lock引用 -> slot 2
        11: monitorenter
        12: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
        15: ldc           #4                  // String ok
        17: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        20: aload_2							// <- slot 2(lock引用)
        21: monitorexit						// monitorexit(lock引用)
        22: goto          30
        25: astore_3						// any -> slot 3
        26: aload_2							// <- slot 2(lock引用)
        27: monitorexit						// monitorexit(lock引用)
        28: aload_3
        29: athrow
        30: return
      Exception table:
         from    to  target type
            12    22    25   any
            25    28    25   any
      LineNumberTable:
        line 6: 0
        line 7: 8
        line 8: 12
        line 9: 20
        line 10: 30
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      31     0  args   [Ljava/lang/String;
            8      23     1  lock   Ljava/lang/Object;

在這裏插入圖片描述
3. 編譯期處理
在這裏插入圖片描述
3.1 默認構造器
在這裏插入圖片描述
3.2 自動拆裝箱
在這裏插入圖片描述
顯然之前版本的代碼太麻煩了，需要在基本類型和包裝類型之間來回轉換（尤其是集合類中操作的都是包裝類型），因此這些轉換的事情在 JDK 5 以後都由編譯器在編譯階段完成。即 代碼片段1 都會在編譯階段被轉換爲 代碼片段2。

3.3 泛型集合取值
在這裏插入圖片描述
擦除的是字節碼上的泛型信息，可以看到 LocalVariableTypeTable 仍然保留了方法參數泛型的信息
在這裏插入圖片描述
3.4 可變參數
在這裏插入圖片描述3.5 foreach 循環

package cn.itcast.jvm.t3.candy;

public class Candy5_1 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5}; // 數組賦初值的簡化寫法也是語法糖哦
        for (int e : array) {
            System.out.println(e);
        }
    }
}

在這裏插入圖片描述
而集合的循環：

package cn.itcast.jvm.t3.candy;

import java.util.Arrays;
import java.util.List;

public class Candy5_2 {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        for (Integer i : list) {
            System.out.println(i);
        }
    }
}

在這裏插入圖片描述
4. 類加載階段
4.1 加載
在這裏插入圖片描述
在這裏插入圖片描述
4.2 鏈接
驗證
驗證類是否符合 JVM規範，安全性檢查。用 UE 等支持二進制的編輯器修改 HelloWorld.class 的魔數，在控制檯運行
在這裏插入圖片描述
準備
在這裏插入圖片描述
解析

將常量池中的符號引用解析爲直接引用

package cn.itcast.jvm.t3.load;
import java.io.IOException;
/**
 * 解析的含義
 */
public class Load2 {
    public static void main(String[] args) throws ClassNotFoundException, IOException {
          ClassLoader classloader = Load2.class.getClassLoader();
          // loadClass 方法不會導致類的解析和初始化
          Class<?> c = classloader.loadClass("cn.itcast.jvm.t3.load.C");
//        new C();
        System.in.read();
    }
}

class C {
    D d = new D();
}

class D {
}

4.3 初始化
在這裏插入圖片描述
   ● loadClass 方法
   ● Class.forName 的參數 2 爲 false 時

驗證（實驗時請先全部註釋，每次只執行其中一個）

package cn.itcast.jvm.t3.load;

import java.io.IOException;

public class Load3 {
    static {
        System.out.println("main init");
    }
    public static void main(String[] args) throws ClassNotFoundException, IOException {
//        // 1. 靜態常量不會觸發初始化
//        System.out.println(B.b);
//        // 2. 類對象.class 不會觸發初始化
//        System.out.println(B.class);
//        // 3. 創建該類的數組不會觸發初始化
//        System.out.println(new B[0]);
        // 4. 不會初始化類 B，但會加載 B、A
//        ClassLoader cl = Thread.currentThread().getContextClassLoader();
//        cl.loadClass("cn.itcast.jvm.t3.load.B");
//        // 5. 不會初始化類 B，但會加載 B、A

//        ClassLoader c2 = Thread.currentThread().getContextClassLoader();
//        Class.forName("cn.itcast.jvm.t3.load.B", false, c2);
        System.in.read();


//        // 1. 首次訪問這個類的靜態變量或靜態方法時
//        System.out.println(A.a);
//        // 2. 子類初始化，如果父類還沒初始化，會引發
//        System.out.println(B.c);
//        // 3. 子類訪問父類靜態變量，只觸發父類初始化
        System.out.println(B.a);
//        // 4. 會初始化類 B，並先初始化類 A
//        Class.forName("cn.itcast.jvm.t3.load.B");


    }
}

class A {
    static int a = 0;
    static {
        System.out.println("a init");
    }
}

class B extends A {
    final static double b = 5.0;
    static boolean c = false;
    static {
        System.out.println("b init");
    }
}

4.4 練習
從字節碼分析，使用 a，b，c 這三個常量是否會導致 E 初始化

package cn.itcast.jvm.t3.load;

public class Load4 {
    public static void main(String[] args) {
        System.out.println(E.a);
        System.out.println(E.b);
        System.out.println(E.c);

    }
}

class E {
    public static final int a = 10;
    public static final String b = "hello";
    public static final Integer c = 20;  // Integer.valueOf(20)
    static {
        System.out.println("init E");
    }
}

典型應用 - 完成懶惰初始化單例模式

package cn.itcast.jvm.t3.load;

public class Load9 {
    public static void main(String[] args) {
//        Singleton.test();
        Singleton.getInstance();
    }

}

class Singleton {

    public static void test() {
        System.out.println("test");
    }

    private Singleton() {}

    private static class LazyHolder{
        private static final Singleton SINGLETON = new Singleton();
        static {
            System.out.println("lazy holder init");
        }
    }

    public static Singleton getInstance() {
        return LazyHolder.SINGLETON;
    }
}

在這裏插入圖片描述
5. 類加載器
以 JDK 8 爲例：
在這裏插入圖片描述
5.1 啓動類加載器
用 Bootstrap 類加載器加載類：

package cn.itcast.jvm.t3.load;

public class F {
    static {
        System.out.println("bootstrap F init");
    }
}

執行

package cn.itcast.jvm.t3.load;

public class Load5_1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> aClass = Class.forName("cn.itcast.jvm.t3.load.F");
        System.out.println(aClass.getClassLoader()); // AppClassLoader  ExtClassLoader
    }
}

輸出
在這裏插入圖片描述
在這裏插入圖片描述
5.2 擴展類加載器
在這裏插入圖片描述在這裏插入圖片描述
5.3 雙親委派模式
所謂的雙親委派，就是指調用類加載器的 loadClass 方法時，查找類的規則
在這裏插入圖片描述
1 sun.misc.Launcher-AppClassLoader //1 處， 開始查看已加載的類，結果沒有
2 sun.misc.Launcher-AppClassLoader // 2 處，委派上級sun.misc.Launcher-ExtClassLoader.loadClass()
3. sun.misc.Launcher–ExtClassLoader // 1 處，查看已加載的類，結果沒有
4.sun.misc.Launcher-ExtClassLoader // 3 處，沒有上級了，則委派BootstrapClassLoader查找
5. BootstrapClassLoader 是在 JAVA_HOME/jre/lib 下找 H 這個類，顯然沒有
6. sun.misc.Launcher-ExtClassLoader // 4 處，調用自己的 findClass 方法，是在
JAVA_HOME/jre/lib/ext 下找 H 這個類，顯然沒有，回到sun.misc.Launcher-AppClassLoader 的 // 2 處
7. 繼續執行到 sun.misc.Launcher-AppClassLoader // 4 處，調用它自己的 findClass 方法，在classpath 下查找，找到了

總結：
在這裏插入圖片描述

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

「Java開發指南」如何用MyEclipse搭建GWT 2.1和Spring？（二）

本教程將指導您如何生成一個可運行的Google Web Toolkit (GWT) 2.1和Spring應用程序，該應用程序爲域模型實現了CRUD應用程序模式。在本教程中，您將學習如何： 安裝Google Eclipse插件 爲GWT配置

原創 2024-05-17 12:21:26

Java ThreadPoolShutdown

CountDownLatch 是 Java 中的一個同步工具類，它允許一個或多個線程等待一系列指定操作執行完成。CountDownLatch 的主要方法有兩個：await() 方法等待 countDown 方法被調用指定的次數後繼續執行，c

原創 2024-05-17 02:06:32

通過MVEL表達式和Apache Chain職責鏈模式解耦MQ消息處理節點的實踐應用

導讀 本文主要講解了MVEL表達式和責任鏈設計模式相結合一起的消息處理解決方案設計、解耦消息處理節點以及方便代碼維護擴展。通過“訂單拆單消息”的接入作爲具體實踐案例，簡要闡述了MVEL表達式和Apache Chain職責鏈設計模式應用場景。

原創 2024-05-16 23:56:24

Spring @EnableXxx註解的使用理解

@EnableXxx註解 Spring有很多@EnableXxx這種形式的註解，類似於可以一鍵打開某項功能，相當於暴露給用戶的一種便捷的配置API，例如 @EnableAsync 激活異步執行能力，@EnableTransactionMan

原創 2024-05-16 23:48:06

java將list結果分成3份執行 原創

Java將List結果分成3份執行 在Java編程中，有時候我們需要將一個List集合中的元素分成幾部分進行處理。這種情況下，我們可以使用Java的相關類庫和API來實現這一需求。在本文中，我們將介紹如何使用Java將List結果分成3份執

文文1 2024-05-16 02:09:55

OSS_PIPE：Rust編寫的大規模文件遷移工具

‍ 隨着業務的發展，文件數量和文件大小會急劇增加，文件遷移的數量和難度不斷攀升。oss_pipe 是rust編寫的文件遷移工具，旨在支撐大規模的文件遷移場景。 編寫 oss_pipe 的初衷 •同類產品面臨的問題 •rust 語

京東雲開發者 2024-05-15 23:59:27

高效調度新篇章：詳解DolphinScheduler 3.2.0生產級集羣搭建

轉載自tuoluzhe8521 導讀：通過簡化複雜的任務依賴關係， DolphinScheduler爲數據工程師提供了強大的工作流程管理和調度能力。在3.2.0版本中，DolphinScheduler帶來了一系列新功能和改進，使其在生產環

原創 2024-05-15 21:22:54

Spring cloud gateway入門

微服務Gateway 微服務網關部署在前端Nginx網關和後端微服務之間，Nginx一般充當流量網關，而微服務網關屬於一種業務型 網關，微服務網關層爲後端的微服務羣組提供統一的接入地址，其核心功能是統一做服務路由，在路由基礎上還 可以實現一

原創 2024-05-15 11:50:15

JDBC連接openGauss6.0和PostgreSQL16.2性能對比

本文分享自華爲雲社區《JDBC連接openGauss6.0和PostgreSQL16.2性能對比》，作者： Gauss松鼠會小助手。 PostgreSQL vs openGauss 01 前置準備 安裝JDK： 詳細安裝步驟請問度娘，輸

原創 2024-05-14 11:00:08

爲什麼阿里不建議用excutors創建線程池

1 前言：         大家都知道，阿里規範中有一條是不允許用excutors去創建線程池，而是採用ThreadPoolExecutor的原生方式去創建。很早就聽過所過這種說法，但是一直都沒去搞清楚是爲什麼，今天就查閱資料去了解了這

原創 2024-05-14 02:07:06

Java遊戲服務器3

1)編碼     消息長度(short int-->2個字節) + 消息編號(short int--》2個字節) + 消息體 2)Protobuf協議文檔     (1)syntax="proto3";     (2)命名格式       

osc_hwc3munb 2024-05-14 02:04:28

Android內存管理機制官方詳解文檔

很早之前寫過一篇《Android內存管理機制詳解》點擊量已7萬+，現把Google官方文檔整理輸出一下，供各位參考。 一、內存管理概覽 Android 運行時 (ART) 和 Dalvik 虛擬機使用分頁和內存映射來管理內存。這意味着應用

osc_51airx3z 2024-05-14 00:37:42

OSS_PIPE：Rust編寫的大規模文件遷移工具| 京東雲技術團隊

文盤rust 好久沒有更新了。這段時間筆者用rust寫了個小東西，跟各位分享一下 背景 隨着業務的發展，文件數量和文件大小會急劇增加，文件遷移的數量和難度不斷攀升。oss_pipe 是rust編寫的文件遷移工具，旨在支撐大規模的文件遷移場

原創 2024-05-13 23:59:27

面試官：說說你對序列化的理解

本文主要內容 背景 在Java語言中，程序運行的時候，會產生很多對象，而對象信息也只是在程序運行的時候纔在內存中保持其狀態，一旦程序停止，內存釋放，對象也就不存在了。 怎麼能讓對象永久的保存下來呢？--------對象序列化 。 何

osc_61miaq6u 2024-05-13 22:58:28

JAVA基礎之常用類（一）String

綱要 String StringBuffer 基礎類型對應的8個包裝類 日期相關類 數字相關類 Random Enum 1. 理解String類的存儲原理 String類是不可變類，也就是說String對象聲明後，將不可修改。 S

osc_6mbnx553 2024-05-13 22:07:29