【译】探索 Kotlin 的隐性成本（第三部分）

时间  2019-11-08
标签 探索 kotlin 隐性 成本 第三 部分 繁體版
原文   原文链接

委托属性（Delegated propertie）和区间（range）

本系列关于 Kotlin 的前两篇文章发表以后，读者们纷至沓来的赞誉让我受宠若惊，其中还包括 Jake Wharton 的留言。很乐意和你们再次开始探索之旅。不要错过 第一部分 和 第二部分.html

本文咱们将探索更多关于 Kotlin 编译器的秘密，并提供一些可使代码更高效的建议。前端

委托属性

委托属性 是一种经过委托实现拥有 getter 和可选 setter 的 属性，并容许实现可复用的自定义属性。java

class Example {
    var p: String by Delegate()
}复制代码

委托对象必须实现一个拥有 getValue() 方法的操做符，以及 setValue() 方法来实现读/写属性。些方法将会接受包含对象实例以及属性元数据做为额外参数。react

当一个类声明委托属性时，编译器生成的代码会和以下 Java 代码类似。android

public final class Example {
   @NotNull
   private final Delegate p$delegate = new Delegate();
   // $FF: synthetic field
   static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(Reflection.getOrCreateKotlinClass(Example.class), "p", "getP()Ljava/lang/String;"))};

   @NotNull
   public final String getP() {
      return this.p$delegate.getValue(this, $$delegatedProperties[0]);
   }

   public final void setP(@NotNull String var1) {
      Intrinsics.checkParameterIsNotNull(var1, "<set-?>");
      this.p$delegate.setValue(this, $$delegatedProperties[0], var1);
   }
}复制代码

一些静态属性元数据被加入到类中，委托在类的构造函数中初始化，并在每次读写属性时调用。ios

委托实例

在上面的例子中，建立了一个新的委托实例来实现属性。这就要求委托的实现是有状态的，例如当其内部缓存计算结果时：git

class StringDelegate {
    private var cache: String? = null

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        var result = cache
        if (result == null) {
            result = someOperation()
            cache = result
        }
        return result
    }
}复制代码

与此同时，当须要额外的参数时，须要创建新的委托实例，并将其传递到构造器中：github

class Example {
    private val nameView by BindViewDelegate<TextView>(R.id.name)
}复制代码

但也有一些状况是只须要一个委托实例来实现任何属性的：当委托是无状态，而且它所须要的惟一变量就是已经提供好的包含对象实例和委托名称时，能够经过将其声明为 object 来替代 class 实现一个单例委托。后端

举个例子，下面的单例委托从 Android Activity 中取回与给定 tag 相匹配的 Fragment：api

object FragmentDelegate {
    operator fun getValue(thisRef: Activity, property: KProperty<*>): Fragment? {
        return thisRef.fragmentManager.findFragmentByTag(property.name)
    }
}复制代码

相似地，任何已有类均可以经过扩展变成委托。getValue() 和 setValue() 也能够被声明成 扩展方法 来实现。Kotlin 已经提供了内置的扩展方法来容许将 Map and MutableMap 实例用做委托，属性名做为其中的键。

若是你选择复用相同的局部委托实例来在一个类中实现多属性，你须要在构造函数中初始化实例。

注意：从 Kotlin 1.1 开始，也能够声明 方法局部变量声明为委托属性。在这种状况下，委托能够直到该变量在方法内部声明的时候才去初始化，而没必要在构造函数中就执行初始化。

类中声明的每个委托属性都会涉及到与之关联委托对象的开销，并会在类中增长一些元数据。
若是可能的话，尽可能在不一样的属性间复用委托。
同时也要考虑一下若是须要声明大量委托时，委托属性是否是一个好的选择。

泛型委托

委托方法也能够被声明成泛型的，这样一来不一样类型的属性就能够复用同一个委托类了。

private var maxDelay: Long by SharedPreferencesDelegate<Long>()复制代码

然而，若是像上例那样对基本类型使用泛型委托的话，即使声明的基本类型非空，也会在每次读写属性的时候触发装箱和拆箱的操做。

对于非空基本类型的委托属性来讲，最好使用给定类型的特定委托类而不是泛型委托来避免每次访问属性时增长装箱的额外开销。

标准委托： lazy()

针对常见情形，Kotlin 提供了一些标准委托，如 Delegates.notNull()、 Delegates.observable() 和 lazy()。

lazy() 是一个在第一次读取时经过给定的 lambda 值来计算属性的初值，并返回只读属性的委托。

private val dateFormat: DateFormat by lazy {
    SimpleDateFormat("dd-MM-yyyy", Locale.getDefault())
}复制代码

这是一种简洁的延迟高消耗的初始化至其真正须要时的方式，在保留代码可读性的同时提高了性能。

须要注意的是，lazy() 并非内联函数，传入的 lambda 参数也会被编译成一个额外的 Function 类，而且不会被内联到返回的委托对象中。

常常被忽略的一点是 lazy() 有可选的 mode 参数 来决定应该返回 3 种委托的哪种：

public fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
public fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
        when (mode) {
            LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
            LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
            LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
        }复制代码

默认模式 LazyThreadSafetyMode.SYNCHRONIZED 将提供相对耗费昂贵的 双重检查锁 来保证一旦属性能够从多线程读取时初始化块能够安全地执行。

若是你确信属性只会在单线程（如主线程）被访问，那么能够选择 LazyThreadSafetyMode.NONE 来代替，从而避免使用锁的额外开销。

val dateFormat: DateFormat by lazy(LazyThreadSafetyMode.NONE) {
    SimpleDateFormat("dd-MM-yyyy", Locale.getDefault())
}复制代码

使用 lazy() 委托来延迟初始化时的大量开销以及指定模式来避免没必要要的锁。

区间

区间 是 Kotlin 中用来表明一个有限的值集合的特殊表达式。值能够是任何 Comparable 类型。 这些表达式的形式都是建立声明了 ClosedRange 接口的方法。建立区间的主要方法是 .. 操做符方法。

包含

区间表达式的主要做用是使用 in 和 !in 操做符实现包含和不包含。

if (i in 1..10) {
    println(i)
}复制代码

该实现针对非空基本类型的区间（包括 Int、Long、Byte、Short、Float、Double 以及 Char 的值）实现了优化，因此上面的代码能够被优化成这样：

if(1 <= i && i <= 10) {
   System.out.println(i);
}复制代码

零额外支出而且没有额外对象开销。区间也能够被包含在 when 表达式中：

val message = when (statusCode) {
    in 200..299 -> "OK"
    in 300..399 -> "Find it somewhere else"
    else -> "Oops"
}复制代码

相比一系列的 if{...} else if{...} 代码块，这段代码在不下降效率的同时提升了代码的可读性。

然而，若是在声明和使用之间有至少一次间接调用的话，range 会有一些微小的额外开销。好比下面的代码：

private val myRange get() = 1..10

fun rangeTest(i: Int) {
    if (i in myRange) {
        println(i)
    }
}复制代码

在编译后会建立一个额外的 IntRange 对象：

private final IntRange getMyRange() {
   return new IntRange(1, 10);
}

public final void rangeTest(int i) {
   if(this.getMyRange().contains(i)) {
      System.out.println(i);
   }
}复制代码

将属性的 getter 声明为 inline 的方法也没法避免这个对象的建立。这是 Kotlin 1.1 编译器能够优化的一个点。至少经过这些特定的区间类避免了装箱操做。

尽可能在使用时直接声明非空基本类型的区间，不要间接调用，来避免额外区间类的建立。
或者直接声明为常量来复用。

区间也能够用于其余实现了 Comparable 的非基本类型。

if (name in "Alfred".."Alicia") {
    println(name)
}复制代码

在这种状况下，最终实现并不会优化，并且老是会建立一个 ClosedRange 对象，以下面编译后的代码所示：

if(RangesKt.rangeTo((Comparable)"Alfred", (Comparable)"Alicia")
   .contains((Comparable)name)) {
   System.out.println(name);
}复制代码

若是你须要对一个实现了 Comparable 的非基本类型的区间进行频繁的包含的话，考虑将这个区间声明为常量来避免重复建立区间类吧。

迭代：for 循环

整型区间 （除了 Float 和 Double以外其余的基本类型）也是 级数：它们能够被迭代。这就能够将经典 Java 的 for 循环用一个更短的表达式替代。

for (i in 1..10) {
    println(i)
}复制代码

通过编译器优化后的代码实现了零额外开销：

int i = 1;
byte var3 = 10;
if(i <= var3) {
   while(true) {
      System.out.println(i);
      if(i == var3) {
         break;
      }
      ++i;
   }
}复制代码

若是要反向迭代，可使用 downTo() 中缀方法来代替 ..：

for (i in 10 downTo 1) {
    println(i)
}复制代码

编译以后，这也实现了零额外开销：

int i = 10;
byte var3 = 1;
if(i >= var3) {
   while(true) {
      System.out.println(i);
      if(i == var3) {
         break;
      }
      --i;
   }
}复制代码

然而，其余迭代器参数并无如此好的优化。

反向迭代还有一种结果相同的方式，使用 reversed() 方法结合区间：

for (i in (1..10).reversed()) {
    println(i)
}复制代码

编译后的代码并无看起来那么少：

IntProgression var10000 = RangesKt.reversed((IntProgression)(new IntRange(1, 10)));
int i = var10000.getFirst();
int var3 = var10000.getLast();
int var4 = var10000.getStep();
if(var4 > 0) {
   if(i > var3) {
      return;
   }
} else if(i < var3) {
   return;
}

while(true) {
   System.out.println(i);
   if(i == var3) {
      return;
   }

   i += var4;
}复制代码

会建立一个临时的 IntRange 对象来表明区间，而后建立另外一个 IntProgression 对象来反转前者的值。

事实上，任何结合不止一个方法来建立递进都会生成相似的至少建立两个微小递进对象的代码。

这个规则也适用于使用 step() 中缀方法来操做递进的步骤，即便只有一步：

for (i in 1..10 step 2) {
    println(i)
}复制代码

一个次要提示，当生成的代码读取 IntProgression 的 last 属性时会经过对边界和步长的小小计算来决定准确的最后值。在上面的代码中，最终值是 9。

最后，until() 中缀函数对于迭代也颇有用，该函数（执行结果）不包含最大值。

for (i in 0 until size) {
    println(i)
}复制代码

遗憾的是，编译器并无针对这个经典的包含区间围优化，迭代器依然会建立区间对象：

IntRange var10000 = RangesKt.until(0, size);
int i = var10000.getFirst();
int var1 = var10000.getLast();
if(i <= var1) {
   while(true) {
      System.out.println(i);
      if(i == var1) {
         break;
      }
      ++i;
   }
}复制代码

这是 Kotlin 1.1 能够提高的另外一个点
与此同时，能够经过这样写来优化代码：

for (i in 0..size - 1) {
    println(i)
}复制代码

for 循环内部的迭代，最好只用区间表达式的一个单独方法来调用 .. 或 downTo() 来避免额外临时递进对象的建立。

迭代：forEach()

做为 for 循环的替代，使用区间内联的扩展方法 forEach() 来实现类似的效果可能更吸引人。

(1..10).forEach {
    println(it)
}复制代码

但若是仔细观察这里使用的 forEach() 方法签名的话，你就会注意到并无优化区间，而只是优化了 Iterable，因此须要建立一个 iterator。下面是编译后代码的 Java 形式：

Iterable $receiver$iv = (Iterable)(new IntRange(1, 10));
Iterator var1 = $receiver$iv.iterator();

while(var1.hasNext()) {
   int element$iv = ((IntIterator)var1).nextInt();
   System.out.println(element$iv);
}复制代码

这段代码相比前者更为低效，缘由是为了建立一个 IntRange 对象，还须要额外建立 IntIterator。但至少它仍是生成了基本类型的值。

迭代区间时，最好只使用 for 循环而不是区间上的 forEach() 方法来避免额外建立一个迭代器。

迭代：集合

Kotlin 标准库提供了内置的 indices 扩展属性来生成数组和 Collection 的区间。

val list = listOf("A", "B", "C")
for (i in list.indices) {
    println(list[i])
}复制代码

使人惊讶的是，对这个 indices 的迭代获得了编译器的优化：

List list = CollectionsKt.listOf(new String[]{"A", "B", "C"});
int i = 0;
int var2 = ((Collection)list).size() - 1;
if(i <= var2) {
   while(true) {
      Object var3 = list.get(i);
      System.out.println(var3);
      if(i == var2) {
         break;
      }
      ++i;
   }
}复制代码

从上面的代码中咱们能够看到没有建立 IntRange 对象，列表的迭代是以最高效率的方式运行的。

这适用于数组和实现了 Collection 的类，因此你若是指望相同的迭代器性能的话，能够尝试在特定的类上使用本身的 indices 扩展属性。

inline val SparseArray<*>.indices: IntRange
    get() = 0..size() - 1

fun printValues(map: SparseArray<String>) {
    for (i in map.indices) {
        println(map.valueAt(i))
    }
}复制代码

但编译以后，咱们能够发现这并无那么高效率，由于编译器没法足够智能地避免区间对象的产生：

public static final void printValues(@NotNull SparseArray map) {
   Intrinsics.checkParameterIsNotNull(map, "map");
   IntRange var10002 = new IntRange(0, map.size() - 1);
   int i = var10002.getFirst();
   int var2 = var10002.getLast();
   if(i <= var2) {
      while(true) {
         Object $receiver$iv = map.valueAt(i);
         System.out.println($receiver$iv);
         if(i == var2) {
            break;
         }
         ++i;
      }
   }
}复制代码

因此，我会建议你避免声明自定义的 lastIndex 扩展属性：

inline val SparseArray<*>.lastIndex: Int
    get() = size() - 1

fun printValues(map: SparseArray<String>) {
    for (i in 0..map.lastIndex) {
        println(map.valueAt(i))
    }
}复制代码

当迭代没有声明 Collection 的自定义集合 时，直接在 for 循环中写本身的序列区间而不是依赖方法或属性来生成区间，从而避免区间对象的建立。

我在写本文时兴趣盎然，但愿你读起来也同样。可能你还期待之后有更多的文章，但这三篇已经涵盖了我目前想要写的全部内容了。若是喜欢的话请分享。谢谢！

掘金翻译计划 是一个翻译优质互联网技术文章的社区，文章来源为 掘金 上的英文分享文章。内容覆盖 Android、iOS、React、前端、后端、产品、设计 等领域，想要查看更多优质译文请持续关注 掘金翻译计划。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程