深入理解JVM（第三版）

4、Java 语法糖的味道

1. 泛型

   泛型的本质是参数化类型或者参数化多态的应用，即可以将操作的数据类型指定为方法签名中的一种特殊参数，这种参数类型能够用在类、接口和方法的创建中, 分别构成泛型类, 泛型接口和泛型方法.

   Java选择的泛型实现方式叫作类型擦除式泛型(Type Erasure Generics), 而C#选择的泛型实现方式是具现化式泛型(Reified Generics).

   C#里面泛型无论在程序源码里，编译后的中间语言表示里，抑或是运行期的CLR里都是切实存在的，List<int>与List<String>就是两种不同的类型, 它们由系统在运行期生成，有自己独立的虚方法表和类型数据.

   Java语言中的泛型只在程序源码中存在，在编译后的字节码文件中，全部泛型都被被替换为原来的裸类型(Raw Type)，并且在相应的地方插入了强制转型代码，对于运行期的Java语言来说, List<int>与List<String>其实是同一个类型.

   Java的类型擦除式泛型在使用效果上还是运行效率上, 几乎全面落后C#的具现化式泛型, 而唯一优势是实现这种泛型的影响范围上: 只需要在Javac编译器上做出改进即可, 不需要改动字节码, 不需要改动Java虚拟机, 也保证了以前没有使用泛型的库可直接运行在Java 5.0之上.

   public static void method(List<String> list) {
       System.out.println("Invoke method List<String> list");
   }
   public static void method(List<Integer> list) {
       System.out.println("Invoke method List<Integer> list");
   }
   // 以上这两个方法是不能共存的，因为类型擦除
   

   public static String method(List<String> list) {
       System.out.println("Invoke method List<String> list");
       return "";
   }
   public static int method(List<Integer> list) {
       System.out.println("Invoke method List<Integer> list");
       return 1;
   }
   // 以上这两个方法是却是能共存的，
   // Class文件方法表的数据结构中，方法重载要求方法具备不同的特征签名，而返回值不包含在方法的特征签名中，所以返回值不参与重载选择
   // 但在Class文件格式之中，只要描述符不是完全一致的两个方法就可以共存，也就是说，两个方法如果有相同的名称和特征签名，但返回值不同，那么它们也是可以合法共存于一个Class文件中的。
   

   由于Java泛型的引入，Java虚拟机规范做出了相应的修改，引入了诸如Signature, LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题。Signature是其中最重要的一项属性，它的作用是存储一个方法在字节码层面的特征签名，这个属性中保存的参数类型不是原生类型，而是包括了参数化类型的信息。

   所谓的泛型擦除，仅仅对方法的Code属性中的字节码进行擦除，实际上元数据中还是保留了泛型信息，这是我们能通过反射手段取得参数化类型的根本依据。

   值类型可与引用类型一样, 具有构造函数, 方法或是属性字段, 而它与引用类型的区别在于它在赋值的时候通常是整体复制, 而不是像引用类型那样传递引用的; 值类型的实例很容易实现分配在方法的调用栈上, 这意味着值类型会随着当前方法的退出而自动释放, 不会给垃圾收集子系统带来任何压力.

2. 自动装箱，拆箱与遍历循环

   自动装箱、拆箱在编译之后被转化成了对应的包装和还原方法，而遍历循环则是把代码还原成了迭代器的实现（这是为何遍历循环需要被遍历的类实现Iterable接口的原因），变长参数在调用的时候变成一个数组类型的参数。

   public static void main(String[] args) {
       Integer a = 1;
       Integer b = 2;
       Integer c = 3;
       Integer d = 3;
       Integer e = 321;
       Integer f = 321;
       Long g = 3L;
   
       System.out.println(c == d); // true
       System.out.println(e == f); // false
       System.out.println(c == (a + b)); // true
       System.out.println(c.equals(a + b)); // true
       System.out.println(g == (a + b)); // true
       System.out.println(g.equals(a + b)); // false
   }
   public static void main(String[] args) {
       Integer a = 1;
       Integer b = 2;
       Integer c = 3;
       Integer d = 3;
       Integer e = 321;
       Integer f = 321;
       Long g = 3L;
       // Integer中把~128到127的数字缓存了
       System.out.println("c == d : " + (c == d));
       System.out.println("e == f : " + (e == f));
       // 这里a + b自动拆箱
       System.out.println("c == (a + b) : " + (c == (a + b)));
       // Integer中把~128到127的数字缓存了
       System.out.println("c.equals(a + b) : " + (c.equals(a + b)));
       // 这里a + b自动拆箱并升级为long类型
       System.out.println("g == (a + b) : " + (g == (a + b)));
       // g是Long类型,而a + b自动拆箱后再装箱是Integer类型
       System.out.println("g.equals(a + b) : " + (g.equals(a + b)));
   }
   

3. 条件编译

   Java语言进行条件编译，方法就是使用条件为常量的if语句，只能使用条件为常量的if语句才有效果。

   根据布尔常量值的真假，编译器将会把分支中不成立的代码块消除掉，在编译器解除语法糖的阶段中完成，只能写在方法体内部, 只能实现语句基本块级别的条件编译，没有办法实现根据条件调整整个Java类的结构。

   public static void main(String[] args) {
       if (true) {
           System.out.println("Block 1");
       } else {
           System.out.println("Block 2");
       }
   }
   // 被条件编译成：
   public static void main(String[] args) {
       System.out.println("Block 1");
   }
   
   // 使用while不能条件编译，会被拒绝编译
   public static void main(String[] args) {
       // 编译器提示 “Unreachable code”
       while (false) {
           System.out.println("");
       }
   }
   

二、实战：插入式注解处理器

使用注解处理器API编写命名规范检查工具:

1. 需要继承抽象类：javax.annotation.processing.AbstractProcessor，覆盖abstract方法：process()。

2. 方法的第一个参数：annotations：可获取到此注解处理器所需要处理的注解集合

3. 第二个参数：roundEnv：访问到当前这个 轮次(Round) 中的抽象语法树节点，每个语法树节点在这里表示为Element，javax.lang.model包中定义了18类Element。

4. 常用的实例变量：processingEnv，是AbstractProcessor中的一个protected变量，在注解处理器初始化的时候创建-init()方法执行的时候, 代表注解处理器框架提供的一个上下文环境，要创建新的代码，向编译器输出信息，获取其他工具类等都需要用到。

5. 两个可以配合使用的Annotations：@SupportedAnnotationTypes（这个注解处理器对哪些注解感兴趣） 和 @SupportedSourceVersions（可以处理哪些版本的Java代码）。

每个注解处理器在运行的时候都是单例的，如果不需要改变生成语法树的内容，process()方法可返回false，通知编译期这个Round中的代码未发生变化，无须构造新的JavaCompiler实例。

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import java.util.Set;

/
 * 名称检查处理器
 * 1.检查类名称,方法名称,字段名称是否符合驼峰命名法
 * 2.检查常量是否字母全部大写,且用下划线隔开
 *
 * @author lzlg
 * 2023/2/20 11:42
 */
// 支持的所有的注解
@SupportedAnnotationTypes("*")
// 支持的版本
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class NameCheckProcessor extends AbstractProcessor {

    private NameChecker nameChecker;

    /
     * 初始化名称检测器组件
     */
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.nameChecker = new NameChecker(processingEnv);
    }

    /
     * 对输入的语法树的各个节点进行名称检查
     */
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (!roundEnv.processingOver()) {
            for (Element element : roundEnv.getRootElements()) {
                this.nameChecker.checkName(element);
            }
        }
        return false;
    }
}

import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;

/
 * 名称检查器
 *
 * @author lzlg
 * 2023/2/20 11:43
 */
public class NameChecker {

    private NameCheckScanner nameCheckScanner;

    public NameChecker(ProcessingEnvironment processingEnv) {
        this.nameCheckScanner = new NameCheckScanner(processingEnv.getMessager());
    }

    public void checkName(Element element) {
        this.nameCheckScanner.scan(element);
    }
}

import javax.annotation.processing.Messager;
import javax.lang.model.element.*;
import javax.lang.model.util.ElementScanner8;
import javax.tools.Diagnostic;
import java.util.Optional;

/
 * 名称检查浏览器
 *
 * @author lzlg
 * 2023/2/20 11:45
 */
public class NameCheckScanner extends ElementScanner8<Void, Void> {

    private final Messager messager;

    public NameCheckScanner(Messager messager) {
        super();
        this.messager = messager;
    }

    /
     * 检查Java类名
     */
    @Override
    public Void visitType(TypeElement e, Void unused) {
        this.scan(e.getTypeParameters(), unused);
        // 检查是否符合首字母大写驼峰命名法
        Optional<String> optional = NameCheckUtils.checkCamelCase(e, true);
        // 打印optional返回的信息
        optional.ifPresent(message -> this.messager.printMessage(Diagnostic.Kind.WARNING, message, e));
        super.visitType(e, unused);
        return null;
    }

    /
     * 检查方法名
     */
    @Override
    public Void visitExecutable(ExecutableElement e, Void unused) {
        if (e.getKind() == ElementKind.METHOD) {
            Name name = e.getSimpleName();
            if (name.contentEquals(e.getEnclosingElement().getSimpleName())) {
                this.messager.printMessage(Diagnostic.Kind.WARNING,
                        "一个普通方法" + name + "不应当与类名重复,避免与构造函数产生混肴.", e);
            }
            // 检查是否符合驼峰命名法,首字母小写
            Optional<String> optional = NameCheckUtils.checkCamelCase(e, false);
            // 打印optional返回的信息
            optional.ifPresent(message -> this.messager.printMessage(Diagnostic.Kind.WARNING, message, e));
        }
        super.visitExecutable(e, unused);
        return null;
    }

    /
     * 检查变量名
     */
    @Override
    public Void visitVariable(VariableElement e, Void unused) {
        // 如果是枚举常量
        if (e.getKind() == ElementKind.ENUM_CONSTANT
                // 常量值不为空
                || e.getConstantValue() != null
                // 或者是常量
                || NameCheckUtils.isConstant(e)) {
            // 检查常量是否符合命名规范
            Optional<String> optional = NameCheckUtils.checkAllCaps(e);
            // 打印optional返回的信息
            optional.ifPresent(message -> this.messager.printMessage(Diagnostic.Kind.WARNING, message, e));
        } else {
            // 检查普通字段是否符合命名规范
            Optional<String> optional = NameCheckUtils.checkCamelCase(e, false);
            // 打印optional返回的信息
            optional.ifPresent(message -> this.messager.printMessage(Diagnostic.Kind.WARNING, message, e));
        }
        super.visitVariable(e, unused);
        return null;
    }

}

import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.VariableElement;
import java.util.EnumSet;
import java.util.Optional;

/
 * @author lzlg
 * 2023/2/20 11:53
 */
public class NameCheckUtils {
    private NameCheckUtils() {
    }

    /
     * 检查一个变量是否是常量
     */
    public static boolean isConstant(VariableElement e) {
        // 在接口中的变量是常量
        if (e.getEnclosingElement().getKind() == ElementKind.INTERFACE) {
            return true;
        }
        // 普通字段必须是public static final修饰的
        return e.getKind() == ElementKind.FIELD &&
                e.getModifiers().containsAll(EnumSet.of(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL));
    }

    /
     * 检查是否符合驼峰命名法
     *
     * @param initialCaps 首字母是否大写
     */
    public static Optional<String> checkCamelCase(Element e, boolean initialCaps) {
        // 获取名称
        String name = e.getSimpleName().toString();
        // 单词前一个字符是否大写
        boolean previousUpper = false;
        // 标志是否校验成功
        boolean conventional = true;
        // 首字母
        int firstCodePoint = name.codePointAt(0);
        // 判断首字母是否大写
        if (Character.isUpperCase(firstCodePoint)) {
            previousUpper = true;
            // 如果要求首字母小写,则违反命名规则,直接返回
            if (!initialCaps) {
                return Optional.of("名称" + name + "应当以小写字母开头.");
            }
            // 判断首字母是否小写
        } else if (Character.isLowerCase(firstCodePoint)) {
            // 如果要求首字母大写,则违反命名规则,直接返回
            if (initialCaps) {
                return Optional.of("名称" + name + "应当以大写字母开头.");
            }
        } else {
            conventional = false;
        }
        // 如果首字母检查通过,开始检查其余字母
        if (conventional) {
            int cp = firstCodePoint;
            // 遍历名称
            for (int i = Character.charCount(cp); i < name.length(); i += Character.charCount(cp)) {
                cp = name.codePointAt(i);
                // 如果字母是大写
                if (Character.isUpperCase(cp)) {
                    // 如果前面已有大写字母,则不符合命名规则
                    if (previousUpper) {
                        conventional = false;
                        break;
                    }
                    // 否则标记前面有大写字母
                    previousUpper = true;
                } else {
                    // 否则前面没有大写字母
                    previousUpper = false;
                }
            }
        }

        // 判断是否符合驼峰命名法
        if (!conventional) {
            return Optional.of("名称" + name + "应当符合驼峰命名法.");
        }
        return Optional.empty();
    }

    /
     * 检查是否全部大写,且有下划线
     */
    public static Optional<String> checkAllCaps(Element e) {
        // 获取名称
        String name = e.getSimpleName().toString();
        // 标志是否校验成功
        boolean conventional = true;
        // 首字母
        int firstCodePoint = name.codePointAt(0);
        // 判断首字母是否大写
        if (!Character.isUpperCase(firstCodePoint)) {
            conventional = false;
        } else {
            // 标志前面已经有下划线
            boolean previousUnderscore = false;
            int cp = firstCodePoint;
            // 遍历name字符串取出每个字符
            for (int i = Character.charCount(cp); i < name.length(); i += Character.charCount(cp)) {
                cp = name.codePointAt(i);
                // 如果是下划线,如果前面有下划线,则不符合命名规则,直接break跳出循环
                if (cp == (int) '_') {
                    if (previousUnderscore) {
                        conventional = false;
                        break;
                    }
                    // 如果有下划线,则标记前面有下划线
                    previousUnderscore = true;
                } else {
                    // 如果不是下划线,则标记前面没有下划线
                    previousUnderscore = false;
                    // 检查字符是否大写且不是数字
                    if (!Character.isUpperCase(cp) && !Character.isDigit(cp)) {
                        conventional = false;
                        break;
                    }
                }
            }
        }
        if (!conventional) {
            return Optional.of("常量" + name + "应当全部以大写字母或下划线命名,并以字母开头.");
        }
        return Optional.empty();
    }

    public static void main(String[] args) {
        String name = "hello,world";
        System.out.println(name.codePointAt(2));
        System.out.println(Character.charCount(name.codePointAt(2)));
    }
}

/
 * 测试名称检查器的代码
 * javac -processor NameCheckProcessor BADLY_NAMED_CODE.java
 *
 * @author lzlg
 * 2023/2/20 14:58
 */
public class BADLY_NAMED_CODE {

    enum colors {
        red, blue, green;
    }

    static final int _FORTY_TWO = 42;

    public static int NOT_A_CONSTANT = _FORTY_TWO;

    protected void BADLY_NAMED_CODE() {
        return;
    }

    protected void NOTcamelCASEmethodNAME() {
        return;
    }
}

# 编译程序为字节码
javac HelloWorld.java
java HelloWorld
# 输出HelloWorld的Class文件编译好的静态链接库
jaotc --output libHelloWorld.so HelloWorld.class
# 使用Linux的ldd命令来确认是否是一个静态链接库
ldd libHelloWorld.so
# 使用nm命令来确认其中是否包含了HelloWorld的构造函数和main()方法的入口信息:
nm libHelloWorld.so
# 使用静态链接库来输出HelloWorld
java -XX:AOTLibrary=./libHelloWorld.so HelloWorld

# 带java虚拟机启动参数的,使用-J参数传递与目标虚拟机相关的运行时参数
jaotc -J-XX:+UseCompressedOops -J-XX:+UseG1GC -J-Xmx4g --output libjava.base-coop.so --module java.base

// 优化前的原始代码
static class B {
    int value;
    final int get() {
        return value;
    }
}

public void foo() {
    y = b.get();
    // ...do stuff...
    z = b.get();
    sum = y + z;
}
// 首先进行方法内联 Method Inlining
// 方法内联主要目的：一是除去方法调用成本，二是为其他优化建立良好的基础
public void foo() {
    y = b.value;
    // ...do stuff...
    z = b.value;
    sum = y + z;
}
// 下一步进行冗余访问消除（Redundant Loads Elimination）
// 假设中间代码不会改变b.value的值，这样可以把b.value替换为 z=y
public void foo() {
    y = b.value;
    // ...do stuff...
    z = y;
    sum = y + z;
}
// 第三步进行复写传播（Copy Propagation）
// 因为z与变量y完全相等，可使用y代替z
public void foo() {
    y = b.value;
    // ...do stuff...
    y = y;
    sum = y + y;
}
// 第三步进行无用代码消除（Dead Code Elimination）
// 代码中 y = y是没有意义的
public void foo() {
    y = b.value;
    // ...do stuff...
    sum = y + y;
}

int d = (c * b) * 12 + a + (a + b * c);
// c * b 与 b * c是一样的表达式，简化为
int d = E * 12 + a + (a + E);
// 根据具体的上下文，进行代数化简，变为
int d = E * 13 + a * 2;

volatile boolean shutdown;

public void shutdown() {
    shutdown = true;
}

public void doWork() {
    while (!shutdown) {
        // do stuff
    }
}

Map configOptions;
char[] configText;
volatile boolean initialized = false;

// 假设以下代码在线程A中执行
// 模拟读取配置信息，当读取完成后，将initialized置为true来通知其他线程配置可用
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfigOptions(configText, confitOptions);
initialized = true;

// 假设以下代码在线程B中执行
// 等待initialized为true，代表线程A已经被配置信息初始化完成
while (!initialized) {
    sleep();
}
doSomethingWithConfig();