CompositeDisposable 会导致内存泄漏，直到 clear 或 dispose 调用？

Question

Disposable添加到遗嘱中的每个都被CompositeDisposable强烈引用，CompositeDisposable直到CompositeDisposable清除或处置。这将防止收集订阅者（一次性）强引用的对象。我应该在添加Disposable到WeakReference之前将所有内容包装起来CompositeDisposable吗？或者只是忽略并让CompositeDisposable将来清除。

Answer 1

订阅时上游对下游的强引用。当上游没有完成任务时，最终的Disposable Observer仍然可以被这个容器处理掉。

import io.reactivex.disposables.Disposable

import io.reactivex.exceptions.CompositeException

import io.reactivex.internal.disposables.DisposableContainer

import java.util.*

import kotlin.collections.ArrayList

class WeakDisposableContainer : DisposableContainer, Disposable {

    private val container = WeakHashMap<Disposable, Any>()

    @Volatile

    private var disposed = false

    override fun add(d: Disposable): Boolean {

        if (!disposed) {

            synchronized(this) {

                if (!disposed) {

                    container[d] = Unit

                    return true

                }

            }

        }

        d.dispose()

        return false

    }

    override fun remove(d: Disposable): Boolean {

        if (delete(d)) {

            d.dispose()

            return true

        }

        return false

    }

    override fun delete(d: Disposable): Boolean {

        if (disposed) return false

        synchronized(this) {

            if (disposed) return false

            return container.remove(d) != null

        }

    }

    override fun isDisposed(): Boolean = disposed

    override fun dispose() {

        clear()

        disposed = true

    }

    fun clear() {

        if (disposed) return

        val d: Iterable<Disposable>

        synchronized(this) {

            if (disposed) return

            d = ArrayList(container.keys)

            container.clear()

        }

        val err = d.mapNotNull { catchThrowable { it.dispose() } }

        if (err.isNotEmpty()) throw CompositeException(err)

    }

}

inline fun catchThrowable(block: () -> Unit): Throwable? = try {

    block()

    null

} catch (e: Throwable) {

    e

}