【译】探索 Kotlin 的隐性成本(第三部分)
- 原文地址:Exploring Kotlin’s hidden costs — Part 3
- 原文作者:Christophe B.
- 译文出自:掘金翻译计划
- 本文永久链接:github.com/xitu/gold-m…
- 译者:PhxNirvana
- 校对者:Zhiw、Feximin
委托属性(Delegated propertie)和区间(range)
本系列关于 Kotlin 的前两篇文章发表之后,读者们纷至沓来的赞誉让我受宠若惊,其中还包括 Jake Wharton 的留言。很乐意和大家再次开始探索之旅。不要错过 第一部分 和 第二部分.
本文我们将探索更多关于 Kotlin 编译器的秘密,并提供一些可以使代码更高效的建议。
委托属性
委托属性 是一种通过委托实现拥有 getter 和可选 setter 的 属性,并允许实现可复用的自定义属性。
class Example {var p: String by Delegate()
}
委托对象必须实现一个拥有 getValue()
方法的操作符,以及 setValue()
方法来实现读/写属性。些方法将会接受包含对象实例以及属性元数据作为额外参数。
当一个类声明委托属性时,编译器生成的代码会和如下 Java 代码相似。
public final class Example {@NotNullprivate final Delegate p$delegate = new Delegate();// $FF: synthetic fieldstatic final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(Reflection.getOrCreateKotlinClass(Example.class), "p", "getP()Ljava/lang/String;"))};@NotNullpublic 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);}
}
一些静态属性元数据被加入到类中,委托在类的构造函数中初始化,并在每次读写属性时调用。
委托实例
在上面的例子中,创建了一个新的委托实例来实现属性。这就要求委托的实现是有状态的,例如当其内部缓存计算结果时:
class StringDelegate {private var cache: String? = nulloperator fun getValue(thisRef: Any?, property: KProperty<*>): String {var result = cacheif (result == null) {result = someOperation()cache = result}return result}
}
与此同时,当需要额外的参数时,需要建立新的委托实例,并将其传递到构造器中:
class Example {private val nameView by BindViewDelegate<TextView>(R.id.name)
}
但也有一些情况是只需要一个委托实例来实现任何属性的:当委托是无状态,并且它所需要的唯一变量就是已经提供好的包含对象实例和委托名称时,可以通过将其声明为 object
来替代 class
实现一个单例委托。
举个例子,下面的单例委托从 Android Activity
中取回与给定 tag 相匹配的 Fragment
:
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..10fun 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: IntRangeget() = 0..size() - 1fun 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: Intget() = size() - 1fun printValues(map: SparseArray<String>) {for (i in 0..map.lastIndex) {println(map.valueAt(i))}
}
当迭代没有声明
Collection
的自定义集合 时,直接在for
循环中写自己的序列区间而不是依赖方法或属性来生成区间,从而避免区间对象的创建。
我在写本文时兴趣盎然,希望你读起来也一样。可能你还期待以后有更多的文章,但这三篇已经涵盖了我目前想要写的所有内容了。如果喜欢的话请分享。谢谢!
【译】探索 Kotlin 的隐性成本(第三部分)相关推荐
- 探索Kotlin的隐性成本-2
原文转自探索Kotlin的隐性成本-2 第二部分将继续Kotlin编程语言,如果未读第一部分,请先阅读part 1. 让我们重新审视幕后并且发现更多的实现细节关于Kotlin特性. Local fun ...
- 探索Kotlin的隐性成本
转载 自 探索Kotlin的隐性成本 2016年, Jake Wharton发表了一系列有趣的言论关于Java的隐性成本.同一时期他也开始拥护使用Kotlin开发Android,但是几乎不提Kotli ...
- [译]Effective Kotlin系列之探索高阶函数中inline修饰符(三)
简述: 不知道是否有小伙伴还记得我们之前的Effective Kotlin翻译系列,之前一直忙于赶时髦研究Kotlin 1.3中的新特性.把此系列耽搁了,赶完时髦了还是得踏实探究本质和基础,从今天开始 ...
- [译]Effective Kotlin系列之考虑使用原始类型的数组优化性能(五)
翻译说明: 原标题: Effective Kotlin: Consider Arrays with primitives for performance critical processing 原文地 ...
- [译]使用MVI打造响应式APP(三):状态折叠器
原文:REACTIVE APPS WITH MODEL-VIEW-INTENT - PART3 - STATE REDUCER 作者:Hannes Dorfmann 译者:却把清梅嗅 在上一章节中,我 ...
- 隐性解析_开发移动应用程序的隐性成本
隐性解析 More and more companies are realizing just how valuable a mobile application can be for their b ...
- 云计算如何避免隐性成本
云计算有八个不同的方面让IT管理员措手不及.虽然有些方面涉及平台即服务(PaaS)或基础设施即服务(IaaS)云模式,不过要牢记:软件即服务(SaaS)模式同样面临隐性成本.虽然你可能没必要为忘了某个 ...
- kotlin ++ --_顺便说一句-探索Kotlin代表团
kotlin ++ -- by Adam Arold 亚当·阿罗德(Adam Arold) 顺便说一句-探索Kotlin代表团 (By the way - exploring delegation i ...
- 数据蒋堂 | 内存数据集产生的隐性成本
作者:蒋步星 来源:数据蒋堂 本文共1500字,建议阅读7分钟. 本文带你了解内存数据集的工作原理. 当我们要对数据做一些非常规的复杂运算时,通常要将数据装入内存.现在也有不少程序设计语言提供了内存数 ...
最新文章
- linux c 文件描述符 得到 文件名
- Linux bash命令操作和VI编辑器操作
- Python 相对路径、绝对路径的写法实例演示
- Mac配置NDK环境
- C++——《算法分析》实验伍——箱子装载问题
- 开发者神器!Windows上最强大的虚拟桌面工具-Dexpot
- 大学计算机入学教育心得1000,新学期入学教育心得体会1000字
- 27岁后月薪低于8K,会被淘汰吗?
- 精选|2018年6月R新包推荐
- Unity 场景分页插件 World Streamer 支持无限大地图的解决方案(一)
- 【大数据部落】R语言实现:混合正态分布EM最大期望估计法
- chrome 迅雷下载 支持插件, 让chrome支持迅雷
- 服务器远程关机软件,实现远程关机需要哪些步骤?向日葵怎么实现远程关机控制?...
- ctrl+alt+方向键 与win7的旋转屏幕冲突解决
- [译]eBay Elasticsearch性能调优实践
- java 中介模式_中介者模式
- 青岛大学计算机科学技术学院图灵班,北京大学计算机实验班(图灵班)介绍
- 正定矩阵的相关性质,凸锥
- contiki学习笔记(一)
- SciTE 编辑器汉化