那些绕不过去的 Java 知识点（一）

关于本文

虽然接触 Java 已经 8 年之久，可惜学习之初的笔记文档没能很好地保存下来。本文是近几年工作学习中遇到的一些零散的知识点，包括了 基础概念、实用的编程技巧、代码可读性、设计模式、性能优化（工具&编码）、测试相关、JVM 相关、常用的工具和常见问题。本着好记性不如烂笔头的初衷，在不断地踩坑和爬坑的过程中，慢慢地记录成文。期待着本文能起到抛砖引玉的作用，以看到大家的真知灼见。

基础知识

注解

GuardedBy

@GuardedBy 注解可以作用于某一个属性或者方法，约定在访问这些被注解标记的资源时，能被同步代码块保护着。简单的使用案例如下：

@GuardedBy("obj")
private ConcurrentMap map = new ConcurrentHashMap<>();
private final Object obj = new Object();

public void put(String k, String v) {
    synchronized (obj) {
        map.put(k, v);
    }
}

/**
 * If you use `error prone` tool to check this, this annotation should be `@SuppressWarnings("GuardedBy")`
 * {@see https://errorprone.info/bugpattern/GuardedBy}
 * {@see https://github.com/apache/incubator-druid/pull/6868#discussion_r249639199}
 */
@SuppressWarnings("FieldAccessNotGuarded")
public void remove(String k) {
    map.remove(k);
}

@Override
public String toString() {
    synchronized (obj) {
        return "GuardedByExample{" +
                "map=" + map +
                '}';
    }
}

Tips: Code Example from Apache Druid；另外，error-prone 工具支持对多种版本的 @GuardedBy 进行检查

InterfaceStability

• @InterfaceStability.Stable
  主版本是稳定的，不同主版本间，可能不兼容

• @InterfaceStability.Evolving
  不断变化中，不同的次版本间，可能不兼容

• @InterfaceStability.Unstable
  不对可靠性和健壮性做任何保证

InterfaceAudience

• @InterfaceAudience.Public
  对所有工程可用

• @InterfaceAudience.LimitedPrivate
  仅限特定的工程，如 HBase、Zookeeper、HDFS 等（以 Hadoop 为例）

• @InterfaceAudience.Private
  仅限于工程内部使用

序列化

transient

给实现了 Serializable 接口的类中的字段，增加 transient 修饰符，则可以让该字段跳过序列化的过程

Tips: Full code is here and here.

类中包含没有实现 Serializable 接口的字段

需要自己实现 serialize 和 deserialize 方法

Tips: Full code is here and here.

实用技巧

Collection 内元素类型转换

// 对集合里面的元素类型进行转换（A -> B）
List variable = (List)(List) collectionOfListA;

集合的差集、交集、并集

// 使用 Guava 中封装的 Sets 类
import com.google.common.collect.Sets;

Sets.difference(set1, set2)
Sets.intersection(set1, set2)
Sets.union(set1, set2)

数组转为 Set

// JDK8
new HashSet<>(Arrays.asList(str.trim().split(",")))
// JDK9+
Set.of(str.trim().split(","));

TransmittableThreadLocal 解决跨父子线程和线程池缓存问题

编码

String tlMsg = "tl";
String ttlMsg = "ttl";

final ThreadLocal tl = new ThreadLocal<>();
tl.set(tlMsg);
final TransmittableThreadLocal ttl = new TransmittableThreadLocal<>();
ttl.set(ttlMsg);

assertEquals(tl.get(), tlMsg);
assertEquals(ttl.get(), ttlMsg);

new Thread(() -> {
    assertNull(tl.get());
    assertEquals(ttl.get(), ttlMsg);
}).start();

Tips: Full code is here.

参考

• TransmittableThreadLocal 详解
• ThreadLocal 父子线程传递实现方案
• ThreadLocal 源码分析解密

可读性

魔法数字

编码过程中，应该避免出现没有声明含义的纯数字

反面示例

// org.apache.kafka.connect.runtime.distributed.DistributedHerder#stop
@Override
public void stop() {
  if (!forwardRequestExecutor.awaitTermination(10000L, TimeUnit.MILLISECONDS))
    forwardRequestExecutor.shutdownNow();
}

正面示例

// 这里除了需要将 10000L 抽象成 FORWARD_REQUEST_SHUTDOWN_TIMEOUT_MS 静态变量
// 还可以进一步使用 10_000L 方便阅读
// 因为这里和时间有关，更进一步，可以使用 TimeUnit.SECONDS.toMillis(10) 来代替纯数字
private static final long FORWARD_REQUEST_SHUTDOWN_TIMEOUT_MS = TimeUnit.SECONDS.toMillis(10);

@Override
public void stop() {
  if (!forwardRequestExecutor.awaitTermination(FORWARD_REQUEST_SHUTDOWN_TIMEOUT_MS, TimeUnit.MILLISECONDS))
    forwardRequestExecutor.shutdownNow();
}

Tips: Full code is here.

字符串判空

反面示例

// org.apache.kafka.connect.runtime.distributed.DistributedHerder#reconfigureConnector
leaderUrl.equals("")

正面示例

// 一方面，需要考虑不能将对象放在 equals 方法之前，避免空指针异常
// 另一方面，使用 `str.length() == 0` 的方式，效率会高一些
// 进一步，使用 isEmpty() 方法，则可以使得代码更加可读
leaderUrl == null || leaderUrl.trim().isEmpty()

Tips: Full code is here.

箭头型代码

反面示例

public void m(String s) {
    if (s != null) {
        if (s.trim().length() > 0) {
            if (s.contains("yuzhouwan")) {
                System.out.println("https://yuzhouwan.com");
            }
        }
    }
}

正面示例

public void m(String s) {
    if (s == null) {
        return;
    }
    if (s.trim().length() == 0) {
        return;
    }
    if (!s.contains("yuzhouwan")) {
        return;
    }
    System.out.println("https://yuzhouwan.com");
}

参考

• 如何重构“箭头型”代码

函数式编程

Optional

反面示例

public Long deserialize(ByteArrayDataInput in) {
    return isNullByteSet(in) ? null : in.readLong();
}

正面示例

return Optional.ofNullable(in)
               .filter(InputRowSerde::isNotNullByteSet)
               .map(ByteArrayDataInput::readLong)
               .get();

参考

• Write null byte when indexing numeric dimensions with Hadoop #7020

anyMatch

反面示例

private boolean isTaskPending(Task task) {
    for (TaskRunnerWorkItem workItem : taskRunner.getPendingTasks()) {
        if (workItem.getTaskId().equals(task.getId())) {
            return true;
        }
    }
    return false;
}

正面示例

final String taskId = task.getId();
return taskRunner.getPendingTasks()
                 .stream()
                 .anyMatch(t -> taskId.equals(t.getTaskId()));

参考

• Run pending tasks when assigned a task that is already pending #6991

设计模式

里氏替换原则

描述

里氏替换原则（Liskov substitution principle，LSP）强调的是 面向对象程序设计中的 可替代性，说明在计算机程序中，如果 S 是 T 的子类型，那么类型 T 的对象可以用类型 S 的对象替换（即 T 类型的对象可以被任何子类型 S 的对象替换），而不改变程序的任何期望属性（正确地执行的任务等）

参考

• wikipedia: Liskov substitution principle
• 面向对象设计原则（三）：里氏替换原则（LSP）

性能优化

工具层面

性能指标监控

3.2.0


  io.dropwizard.metrics
    metrics-core
  ${metrics.version}
  
    
      org.slf4j
      slf4j-api
    
  

JMH 基准测试

增加 Maven 依赖

1.19



    org.openjdk.jmh
    jmh-core
    ${jmh.version}


    org.openjdk.jmh
    jmh-generator-annprocess
    ${jmh.version}

编写 JMH 测试案例

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
public class BenchmarkSimple {

    @Benchmark
    public void bench() {
        add(1, 1);
    }

    private static int add(int a, int b) {
        return a + b;
    }

    /*
    Benchmark               Mode    Cnt     Score        Error     Units
    BenchmarkSimple.bench   thrpt    5  13352311.603 ± 767137.272  ops/ms
     */
    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(BenchmarkSimple.class.getSimpleName())
                .forks(1)
                .warmupIterations(5)
                .measurementIterations(5)
                .threads(10)
                .build();
        new Runner(opt).run();
    }
}

Tips: Full code is here.

优势

• 不和会 JUnit 冲突，不用担心 Jenkins 会自动跑 Benchmark 测试而影响效率（否则需要添加 @Ignore 让 CI 系统忽略掉性能相关的 JUnit 测试用例）
• 支持 warm up，可以解决 JIT 预热问题

BTrace

介绍

BTrace is a safe, dynamic tracing tool for the Java platform. BTrace can be used to dynamically trace a running Java program (similar to DTrace for OpenSolaris applications and OS). BTrace dynamically instruments the classes of the target application to inject tracing code ("bytecode tracing").

参考

• BTrace - a safe, dynamic tracing tool for the Java platform

LooseJar

介绍

分析没有被加载任何 class 的 jar 包，帮助删除工程中不必要的 jar 包。不过，需要注意的是，有些类是动态加载的（比如数据类型转换类的，只有加载数据时才会用到），需要尽可能地多测试，才能保证 LooseJar 分析准确

使用步骤

• 下载
  在 LooseJar 的 release 页面，下载 loosejar-1.1.0.jar

• 拷贝
  将 loosejar.jar 放到应用的 WEB-INF 下的 lib 目录中，比如说路径是 /yuzhouwan/yuzhouwan-site/yuzhouwan-site-web/src/main/webapp/WEB-INF/lib/loosejar.jar

• 配置
  在 IDE 中的 installed JRES 里面的 JDK 处配置 -Dfile.encoding=uft8 -javaagent:/yuzhouwan/yuzhouwan-site/yuzhouwan-site-web/src/main/webapp/WEB-INF/lib/loosejar.jar

• 启动
  启动应用，尽可能做到路径全覆盖地测试应用，让每段代码都被执行到

• 查看结果
  运行 JDK 自带的 Jconsole 工具，选择 BootStrap 的那个端口，然后选择 MBean 下的 com.googlecode.loosejar，并点击 summary，即可看到分析结果

编码层面

并发相关

synchronized

详见，《如何运用 JVM 知识提高编程水平 - synchronized 的性能之争》

StampedLock

特性

该类是一个读写锁的改进，它的思想是读写锁中读不仅不阻塞读，同时也不应该阻塞写

参考

• Java 8 新特性探究（十）StampedLock 将是解决同步问题的新宠
• Java 8 对读写锁的改进：StampedLock

集合优化

HashMap

为什么 Java 8 版本中引入红黑树

• 原因

  JDK8 以前 HashMap 的实现是 数组+链表，即使哈希函数取得再好，也很难达到元素百分百均匀分布

  当 HashMap 中有大量的元素都存放到同一个桶中时，这个桶下有一条长长的链表，这个时候 HashMap 就相当于一个单链表，假如单链表有 n 个元素，遍历的时间复杂度就是 ，完全失去了它的优势

  针对这种情况，JDK8 中引入了 红黑树（查找时间复杂度为 ）来优化这个问题

• 流程

  添加时，当桶中链表个数超过 8 时会转换成红黑树

  删除、扩容时，如果桶中结构为红黑树，并且树中元素个数太少的话，会进行修剪或者直接还原成链表结构

  查找时即使哈希函数设计不合理，大量元素集中在一个桶中，由于有红黑树结构，性能也不会差

Collections 类

空集合

Collections.emptyList() 重用一个对象而不是创建一个新对象，就像 Arrays.asList() 一样。不同的是，Collections.singletonList(something) 是不可变的，而 Arrays.asList(something) 是一个固定大小的 List，其中 List 和 Array 在 Heap 中已经连接。

参考

• Empty list: What is the difference between Arrays.asList() and Collections.emptyList()?
• Arrays.asList() vs Collections.singletonList()

LinkedList vs. ArrayList

LinkedList

• get(int index) is average
• add(E element) is
• add(int index, E element) is average, but when index = 0
• remove(int index) is average
• Iterator.remove() is
• ListIterator.add(E element) is

Note: is average, best case (e.g. index = 0), worst case (middle of list)

ArrayList

• get(int index) is
• add(E element) is amortized, but worst-case since the array must be resized and copied
• add(int index, E element) is average
• remove(int index) is average
• Iterator.remove() is average
• ListIterator.add(E element) is average

参考

• When to use LinkedList over ArrayList ?
• JDK Docs: LinkedList / ArrayList

contains 方法

HashSet

时间复杂度 和 内存使用率 角度看，HashSet 为最佳之选

参考

• Java Collection Performance

toArray 方法

说明

There are two styles to convert a collection to an array: either using a pre-sized array (like c.toArray(new String[c.size()])) or using an empty array (like c.toArray(new String[0]).

In older Java versions using pre-sized array was recommended, as the reflection call which is necessary to create an array of proper size was quite slow. However since late updates of OpenJDK 6 this call was intrinsified, making the performance of the empty array version the same and sometimes even better, compared to the pre-sized version. Also passing pre-sized array is dangerous for a concurrent or synchronized collection as a data race is possible between the size and toArray call which may result in extra nulls at the end of the array, if the collection was concurrently shrunk during the operation.

This inspection allows to follow the uniform style: either using an empty array (which is recommended in modern Java) or using a pre-sized array (which might be faster in older Java versions or non-HotSpot based JVMs).

压测

@State(Scope.Thread)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
public class ToArrayBenchmark {

    @Param({"1", "100", "1000", "5000", "10000", "100000"})
    private int n;

    private final List