Singleton observable query parameter storage... in RxJava...

QueryDefaults.java

public class QueryDefaults {

    private static QueryDefaults _Instance;

    public static synchronized QueryDefaults getInstance() {
        if (_Instance == null) {
            _Instance = new QueryDefaults();
        }
        return _Instance;
    }

    public static Observable<Map<String, String>> create() {
        return getInstance().createInternal();
    }

    public static Action1<String> putQueryParameter(String key) {
        return value -> getInstance().put(key, value);
    }

    public static void removeQueryParameter(String key) {
        getInstance().remove(key);
    }

    final Map<String, String> mQueryParameters = new HashMap<>();
    final List<Subscriber<? super Map<String, String>>> mSubscriber = new ArrayList<>();

    private Observable<Map<String, String>> createInternal() {
        ArrayList<Subscriber<? super Map<String, String>>> subscriberRef = new ArrayList<>();
        Observable<Map<String, String>> observable = Observable.create(subscriber -> {
            subscriber.onNext(mQueryParameters);
            mSubscriber.add(subscriber);
            subscriberRef.add(subscriber);
        });
        // FIXME should clean all subscriber even if on which `unsubscribe()` is not called. 
        // FIXME It's safe for observable with single subscriber but...
        return observable.doOnUnsubscribe(() -> {
            mSubscriber.removeAll(subscriberRef);
            subscriberRef.clear();
        });
    }

    public synchronized void put(String key, String value) {
        mQueryParameters.put(key, value);
        dispatchNext();
    }

    public synchronized void remove(String key) {
        mQueryParameters.remove(key);
        dispatchNext();
    }

    private void dispatchNext() {
        for (Subscriber<? super Map<String, String>> subscriber : mSubscriber) {
            subscriber.onNext(mQueryParameters);
        }
    }
}