前言

刚开始接触kotlin的委托，深深的koltin的委托吸引，初见，so easy，真的是码农的福音，语法糖，简洁；委托，真是方便。

一、Koltin委托避雷指南

我们平时使用的成员变量委托，常见的使用方式如下：

代码如下（示例）：

private val mA:A by lazy { 
        A()
    }

官方是这样描述的：通过by lazy的方式，上述代码中的A对象只会被创建一次，并且只有在第一次调用的时候创建，后面的调用将不会再重复创建。

初次使用发现这种调用方式，真的是太方便了，并且不会多次调用，只有在调用的时候才会被创建。这样做真的没有问题吗？
实验验证如此调用会引发的问题：假如在Service中使用By lazy的方式调用外部的对象，如果Service在销毁的时候，想当然的认为mA这个变量也会被销毁。然后实际是：手动多次强制回收内存，变量依旧存在，不会被销毁。这。。。？？？
让我们来验证下：
（1）创建一个测试Activity

class MainActivity : AppCompatActivity() {

    private val mAnimation: Animation by lazy {
        Animation()
    }

    private val mStr: String by lazy {
        "ok"
    }

    private val number: Int by lazy {
        3 + 4 + 5
    }


    private lateinit var button: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        button = findViewById(R.id.button)
        Log.d("test", "mAnimation=${mAnimation.hashCode()}")
        Log.d("test", "mStr=$mStr")
        Log.d("test", "number=$number")
    }

    fun buttonOnClick(view: View) {
        val intent = Intent(this, MyService::class.java)
        intent.putExtra("cmd", "stop")
        this.startService(intent)
    }
}

(2)创建一个测试Service

class MyService : Service() {

    private val mAnimation: Animation by lazy {
        Animation()
    }

    private val mStr: String by lazy {
        "ok"
    }

    private val number: Int by lazy {
        3 + 4 + 5
    }

    override fun onBind(intent: Intent): IBinder {
       return Binder()
    }

    override fun onCreate() {
        super.onCreate()
        Log.d("test","MyService mAnimation=${mAnimation.hashCode()}")
        Log.d("test","MyService mStr=$mStr")
        Log.d("test","MyService number=$number")
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        val cmd = intent?.getStringExtra("cmd")

        if(cmd == "stop") {
            stopSelf()
        }

        return super.onStartCommand(intent, flags, startId)
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d("test","MyService onDestroy")
    }
}

（3）分别启动Acitivity和Service。
内存如下：

（4）退出Service,查看内存

我们可以看到，Animation的对象变成了一个，但是Service内部的引用变量依旧在。
（5）我们再次退出Activity,多次手动触发回收内存，再看看内存的情况。

明显可以看出，Activity，Service，Animation都已经销毁，但是by lazy的引用依旧在。

总结

by lazy的使用会减少对象的创建，但是随着父容器的销毁，引用的变量并不会销毁，如果比较在意内存的占用，慎用。 委托好用，但是坑也不少，希望这边文章的记录，让大家对kotlin有更深的认识。