区别

从2者的概念上来区分，lateinit是修饰变量和属性,by lazy 是2个单词组成，其中by 是关键字,lazy 是一个函数。

先看看下面的代码，就会很清楚的理解2者之间的区别了。

lateinit

由于kotlin有严格的语法要求变量需要声明是否可以为null，但由于在实际的业务场景中，这个变量必须在某些时候才能做初始化操作，并且这个变量肯定不为null，如果为null，就是逻辑有问题了。这个时候可以使用lateinit来修饰这个变量。如果没有初始化就使用这个变量，那么就会抛出异常。

lateinit的使用

class LateInitExample {
    lateinit var value:String
}

fun main() {
    val example = LateInitExample()
    // 如果没有赋值就使用，直接抛出异常。
    example.value = "lateinit example"
    println("${example.value}")
}

lateinit的具体实现

lateinit可以达到这样的效果，其实非常简单。类似于如下的java代码。

public class LateInit {

    private String value;

    public String getValue() {
        // 如果没有初始化过，就抛出异常
        if (value == null){
            throw new RuntimeException("lateinit property value has not been initialized");
        }
        return value;
    }

    public void setValue(String value) {
        // 这里要做非null检查
        this.value = value;
    }
}

by lazy

前面说了，by 和 lazy要单独拿出来看，不能当做一个整体来看。

by：这里涉及到了kotlin的委托中委托属性。
lazy：一个kotlin的函数

by和委托属性

先简单看一下如果实现委托属性。

import kotlin.reflect.KProperty

class DelegateExample {
    var name:String by Delegate()
}

class Delegate{

    private var _name:String = "default value provide by Delegate"

    operator fun getValue(example: DelegateExample, property: KProperty<*>): String {
        println("Delegate : get Value")
        return _name
    }

    operator fun setValue(example: DelegateExample, property: KProperty<*>, s: String) {
        println("Delegate : set Value: $s")
        _name = s
    }
}

fun main() {
    val example = DelegateExample();
    println(example.name)
    example.name = "tom"
    println(example.name)
}

输出结果：

Delegate : get Value
default value provide by Delegate
Delegate : set Value: tom
Delegate : get Value
tom

简单通俗理解就是这个变量的get，set都是委托给了另外一个类来去操作。
如果是var变量，必须要有getValue和setValue2个方法，val变量不需要setValue方法。
语法是: val/var <属性名>: <类型> by <表达式>

Kotlin 标准库为几种有用的委托提供了工厂方法，延迟属性 Lazy就是其中之一。

lazy

已经知道了by来干什么的，具体怎么用by，我们先来看看by lazy如何使用。

class ByLazyExample {
    val name:String by lazy {
        println("get name by lazy")
        "tom"
    }
}

fun main() {
    val example = ByLazyExample()
    println(example.name)
    println(example.name)
    println(example.name)
}

输出结果：

get name by lazy
tom
tom
tom

我们发现get name by lazy只执行了一次，只有第一次取得时候执行了lazy的代码块。所以by lazy可以做到延迟初始化，等需要的时候再去初始化，并且只会执行一次代码块。

模仿一下lazy的实现

代码块这里是使用了lambda表达式。我们先尝试着根据我们刚才学习的by自己实现一个可以做到上面输出。在上面的DelegateExample中我们已经使用了by，但是我们的get会执行多次，我们试着更新一下上面的代码，模仿一下lazy。

import kotlin.reflect.KProperty

class DelegateExample {
    val name:String by delegate {
        println("get name by lazy")
        "tom"
    }
}

fun delegate(init : () -> String):Delegate{
    return Delegate(init)
}


class Delegate{

    private val _init : () -> String
    constructor(init : () -> String){
        _init = init
    }
    private var _name:String = "default value provide by Delegate"
    private var _nameIsLoad:Boolean = false;

    operator fun getValue(example: DelegateExample, property: KProperty<*>): String {
        if (_nameIsLoad){
            return _name;
        }
        _name = _init()
        _nameIsLoad = true
        return _name
    }
}

fun main() {
    val example = DelegateExample();
    println(example.name)
    println(example.name)
    println(example.name)
}

输出结果：

get name by lazy
tom
tom
tom

这样看着我们写的by delegate和by lazy很像啊。实际上，这个和by lazy的实现真的很像，只是很粗糙。

我们先看一下我们更新了DelegateExample哪些东西，

• 首先定义了一个函数，返回值是Delegate
• Delegate接收一个函数类型参数，新增了一个Boolean值来判断是否已经赋值过了。
• getValue的时候判断如果没有赋值，就通过传递进来的函数赋值，初始化。
• DelegateExample的name变量由var变成了val，这个很好理解，因为既然name的赋值都交给我们自己的lambda来做了，那么setValue就不需要了。这也是为什么kotlin的by lazy不支持var的原因，因为没有了setValue方法实现。

lazy的实现

根据上面我们写的代码，应该基本上对lazy的实现已经清楚了。接下来看一下kotlin是如果实现lazy的。
下面贴出部分代码。

// 跟我们刚才写的很像，有个方法，参数是一个lambda表达式，返回一个Lazy对象
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

// Lazy接口
public interface Lazy<out T> {   
    public val value: T
}

// Lazy的实现类
private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    
    private val lock = lock ?: this
    
    // 采用double check的方式处理value的获取。保证多线程情况下代码块也只会被执行一次。
    override val value: T
        get() {
            val _v1 = _value
            // 采用不是默认值就证明赋值了，不是我们上面自己实现的Boolean值记录。
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }

            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                } else {
                // 执行代码块
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }

看到这里，相信大家只剩下一个疑惑了，为什么没有getValue方法，不是说by的实现需要getValue方法吗？这里，kotlin使用了扩展函数来做。

// 这里返回value，就会执行实现类的override value get了。
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

总结

看完上面的代码，相信已经把lateinit和by lazy解释清楚了。

• 2者的概念不同，一个是延迟初始化，一个是委托属性。
• by lazy只能用在val声明的变量上，为什么上面代码也解释了，并且是线程安全的。

---

初学，有不对的地方欢迎大家指出，互相学习。