private void performLogin(String userId, String pwd){
    Map<String, String> fields = new HashMap<>();
    fields.put("userId", userId);
    fields.put("pwd", pwd);

    userLoginCase.execute(new LoginSubscriber(), fields);
  }

  protected abstract Observable buildUseCaseObservable (Object...param);

  public void execute(Subscriber useCaseSubscriber, Object...param){
    subscription = buildUseCaseObservable(param)
        .subscribeOn(Schedulers.from(threadExecutor))
        .observeOn(postExecutionThread.getScheduler())
        .lift(new OperatorSynchronousUnsubscribe())
        .subscribe(useCaseSubscriber);
  }

public class UserLoginCase extends UseCase {

  private final UserRepository userRepository;

  @Inject
  public UserLoginCase(UserRepository userRepository,
      ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread) {
    super(threadExecutor, postExecutionThread);
    this.userRepository = userRepository;
  }

  @Override protected Observable buildUseCaseObservable(Object...param) {
    return this.userRepository.userLogin((Map<String, String>) param[0]);
  }
}

public interface UserRepository {
  Observable<User> userLogin(final Map<String, String> fields);
}

@Singleton public class UserDataRepository implements UserRepository {

  private final UserDataStoreFactory userDataStoreFactory;
  private final UserEntityDataMapper dataMapper;

  @Inject public UserDataRepository(UserDataStoreFactory dataStoreFactory,
      UserEntityDataMapper userEntityDataMapper) {
    this.userDataStoreFactory = dataStoreFactory;
    this.dataMapper = userEntityDataMapper;
  }

  @Override public Observable<User> userLogin(Map<String, String> fields) {
    final UserDataStore userDataStore = this.userDataStoreFactory.createCloudDataStore();
    return userDataStore.userLogin(fields).map(entity -> this.dataMapper.transform(entity));
  }
}

public interface UserDataStore {
  Observable<UserEntity> userLogin(@NonNull final Map<String, String> fields);
}

public class CloudUserDataStore implements UserDataStore {
  private final RestApi restApi;

  public CloudUserDataStore(RestApi restApi) {
    this.restApi = restApi;
  }

  @Override public Observable<UserEntity> userLogin(@NonNull Map<String, String> fields) {
    return restApi.userLogin(fields);
  }
}

public interface RestApi {
  Observable<UserEntity> userLogin(final Map<String, String> fields);
}

public class RestApiImpl implements RestApi {
  private static RetrofitAPI RETROFIT_CLIENT;

  @Override public Observable<UserEntity> userLogin(final Map<String, String> fields) {
    return RETROFIT_CLIENT.userLogin(fields).timeout(REQUEST_TIMEOUT, TimeUnit.SECONDS);
  }
}

public abstract class UseCaseList extends UseCase {

  //protected Subscription subscription1 = Subscriptions.empty();
  //protected Subscription subscription2 = Subscriptions.empty();
  //protected Subscription subscription3 = Subscriptions.empty();
  //protected Subscription subscription4 = Subscriptions.empty();

  protected Subscription subscription1;
  protected Subscription subscription2;
  protected Subscription subscription3;
  protected Subscription subscription4;

  protected CompositeSubscription mCompositeSubscription = new CompositeSubscription();

  protected UseCaseList(ThreadExecutor threadExecutor, PostExecutionThread postExecutionThread) {
    super(threadExecutor, postExecutionThread);
  }

  protected abstract Observable buildUseCaseObservable1(Object... param);
  protected abstract Observable buildUseCaseObservable2(Object... param);
  protected abstract Observable buildUseCaseObservable3(Object... param);
  protected abstract Observable buildUseCaseObservable4(Object... param);

  @Override public void execute(Subscriber useCaseSubscriber, Object... param) {
    super.execute(useCaseSubscriber, param);
    mCompositeSubscription.add(subscription);
  }

  public void execute1(Subscriber UseCaseSubscriber, Object... param) {
    subscription1 = buildUseCaseObservable1(param).subscribeOn(Schedulers.from(threadExecutor))
        .observeOn(postExecutionThread.getScheduler())
        .lift(new OperatorSynchronousUnsubscribe())
        .subscribe(UseCaseSubscriber);
    mCompositeSubscription.add(subscription1);
  }

  public void execute2(Subscriber UseCaseSubscriber, Object... param) {
    subscription2 = buildUseCaseObservable2(param).subscribeOn(Schedulers.from(threadExecutor))
        .observeOn(postExecutionThread.getScheduler())
        .lift(new OperatorSynchronousUnsubscribe())
        .subscribe(UseCaseSubscriber);
    mCompositeSubscription.add(subscription2);
  }

  public void execute3(Subscriber UseCaseSubscriber, Object... param) {
    subscription3 = buildUseCaseObservable3(param).subscribeOn(Schedulers.from(threadExecutor))
        .observeOn(postExecutionThread.getScheduler())
        .lift(new OperatorSynchronousUnsubscribe())
        .subscribe(UseCaseSubscriber);
    mCompositeSubscription.add(subscription3);
  }

  public void execute4(Subscriber UseCaseSubscriber, Object... param) {
    subscription4 = buildUseCaseObservable4(param).subscribeOn(Schedulers.from(threadExecutor))
        .observeOn(postExecutionThread.getScheduler())
        .lift(new OperatorSynchronousUnsubscribe())
        .subscribe(UseCaseSubscriber);
    mCompositeSubscription.add(subscription4);
  }

  @Override public void unsubscribe() {
    //super.unsubscribe();
    if (mCompositeSubscription.hasSubscriptions()) {
      mCompositeSubscription.unsubscribe();
    }
  }
}