通过使Singleton&amp；的getInstance()方法返回一个可观察的&amp；lt；来使其成为异步方法是个好主意吗？

我有一个单例，它需要几秒钟来实例化。它会使用户界面冻结。因此，我计划使getInstance()方法成为异步方法。编写以下代码是常见做法吗？

/*
 * The singleton class
 */
public class Singleton {

    private static volatile Singleton instance;

    public static Observable<Singleton> getInstance(Context context) {
        return Observable.fromCallable(() -> {
            synchronized (Singleton.class) {
                if (instance == null)
                    instance = new Singleton(context.getApplicationContext());
            }
            return instance;
        });
    }

    private Singleton(Context context) {
        // long running process
    }

    // ...
}



/*
 * The UI class
 */
public class UI extends Activity {

    private Singleton singleton;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Singleton.getInstance(this)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(result -> {
                UI.this.singleton = result
            })
    }

    public void onButtonClick(View v) {
        if (singleton != null)
            singleton.someMethod();
    }
}

如果不是，为什么不是，什么是更好的解决方案？

---

解决方案

您想要的是缓存从可调用对象返回的值，以便下次调用Subscribe时不想再次执行可调用对象。为此， 使用cache运算符。

Single<Integer> cachedValue = Single.fromCallable(() -> {
    Thread.sleep(3000);
    return 5;
}).cache();


cachedValue.subscribe(e -> System.out.println(System.currentTimeMillis() + ": " + e));
cachedValue.subscribe(e -> System.out.println(System.currentTimeMillis() + ": " + e));

您会注意到第二个调用的时间与第一个调用的时间太接近。至少<；3000毫秒