MyDefaultFactory.java

class MyDefaultFactory extends ViewModelProviders.DefaultFactory {
  // constructor

  private final Map<String, ViewModel> mMap = new HashMap<>();

  @Nullable
  private String onetimeCacheKey;

  @MainThread
  public void setKey(@NonNull String key) {
      this.onetimeCacheKey = key;
  }

  @MainThread
  public void clear(@NonNull String key) {
    mMap.remove(key);
  }

  @Override public <T extends ViewModel> T create(Class<T> modelClass) {
    if (onetimeCacheKey != null) {      
      T viewModel = null;

      if (mMap.containsKey(onetimeCacheKey)) {
        ViewModel tmp = mMap.get(onetimeCacheKey);

        if (modelClass.isInstance(tmp)) {
          viewModel = (T) mMap.get(onetimeCacheKey);
        }
      }

      if (viewModel == null) {
        viewModel = super.create(modelClass);
        mMap.put(onetimeCacheKey, viewModel);
      }

      onetimeCacheKey = null;

      return viewModel;
    } else {
      return super.create(modelClass);
    }
  }

  @Override
  public <T extends ViewModel> T create(Class<T> modelClass) {
      return super.create(modelClass);
  }
}

class MyViewModelProvider extends ViewModelProvider {
  private final Factory mFactory;

  // two constructors

  @NonNull @Override public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
      if (mFactory instanceof MyDefaultFactory)
          ((MyDefaultFactory) mFactory).setKey(key);

      return super.get(key, modelClass);
  }
}

public class MyViewModelProviders extends ViewModelProviders {

    @SuppressLint("StaticFieldLeak")
    private static MyDefaultFactory sMyDefaultFactory;

    private static void initializeFactoryIfNeeded(Application application) {
        if (sMyDefaultFactory == null) {
            sMyDefaultFactory = new MyDefaultFactory(application);
        }
    }

    @MainThread
    public static ViewModelProvider of(@NonNull FragmentActivity activity) {
        initializeFactoryIfNeeded(activity.getApplication());
        return new ViewModelProvider(ViewModelStores.of(activity), sMyDefaultFactory);
    }

    @MainThread
    public static ViewModelProvider of(@NonNull Fragment fragment) {
      FragmentActivity activity = fragment.getActivity();
      if (activity == null) {
          throw new IllegalArgumentException(
                  "Can't create ViewModelProvider for detached fragment");
      }
      initializeFactoryIfNeeded(activity.getApplication());
        return new ViewModelProvider(ViewModelStores.of(fragment), sMyDefaultFactory);
    }

    @MainThread
    public static void clear(@NonNull String key) {
      sMyDefaultFactory.clear(key);
    }
}

Usage.java

class Sample1Activity extends FragmentActivity {
  void onCreate(Bundle bundle) {
    // call super
    MyViewModel viewmodel1 = MyViewModelProviders.of(this).get("some", MyViewModel.class);
  }
}

class Sample2Activity extends FragmentActivity {
  void onCreate(Bundle bundle) {
    // call super
    MyViewModel viewmodel2 = MyViewModelProviders.of(this).get("some", MyViewModel.class);
  }
}

// maybe assert(viewModel1 == viewModel2) #=> true