一次失败的SP优化

去到了一个新公司，发现一个神奇的操作：所有数据都是存在同一个sp中的。从源码上看，sp会在new的时候启动异步线程读取整个文件，并parse成map，这会阻塞第一个读写操作；而每次commit/apply的时候，都会写入全量文件。看起来这里有一个性能问题。本着无聊+装逼的心情，做了一个基于一致性哈希的SP。

public class ConsistentHashPreferences implements SharedPreferences {  private PreferenceConfig mPreferenceConfig;  public ConsistentHashPreferences(PreferenceConfig config) {    mPreferenceConfig = config;  }  @Override  public Map<String, ?> getAll() {    Map<String, Object> map = new HashMap<>();    for (SharedPreferences sp : mPreferenceConfig.all()) {      map.putAll(sp.getAll());    }    return map;  }  @Nullable  @Override  public String getString(String key, @Nullable String defValue) {    return mPreferenceConfig.preferenceForKey(key).getString(key, defValue);  }  @Nullable  @Override  public Set<String> getStringSet(String key, @Nullable Set<String> defValues) {    return null;  }  @Override  public int getInt(String key, int defValue) {    return mPreferenceConfig.preferenceForKey(key).getInt(key, defValue);  }  @Override  public long getLong(String key, long defValue) {    return mPreferenceConfig.preferenceForKey(key).getLong(key, defValue);  }  @Override  public float getFloat(String key, float defValue) {    return mPreferenceConfig.preferenceForKey(key).getFloat(key, defValue);  }  @Override  public boolean getBoolean(String key, boolean defValue) {    return mPreferenceConfig.preferenceForKey(key).getBoolean(key, defValue);  }  @Override  public boolean contains(String key) {    return mPreferenceConfig.preferenceForKey(key).contains(key);  }  @Override  public Editor edit() {    return new EditorCache();  }  @Override  public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {  }  @Override  public void unregisterOnSharedPreferenceChangeListener(      OnSharedPreferenceChangeListener listener) {  }  private class EditorCache implements SharedPreferences.Editor {    private Map<Integer, Editor> mEditorCache;    private List<TranscationItem> mTransactions;    private Editor obtainEditor(String key) {      if (mEditorCache == null) {        mEditorCache = new HashMap<>();      }      Editor editor = mEditorCache.get(mPreferenceConfig.hashForKey(key));      if (editor == null) {        editor = mPreferenceConfig.preferenceForKey(key).edit();      }      mEditorCache.put(mPreferenceConfig.hashForKey(key), editor);      return editor;    }    public EditorCache() {      init();    }    private void init() {      mTransactions = new ArrayList<>();    }    @Override    public SharedPreferences.Editor putString(String key, @Nullable String value) {      mTransactions.add(new StringTransactionItem(key, value));      return this;    }    @Override    public SharedPreferences.Editor putStringSet(String key, @Nullable Set<String> values) {      return null;    }    @Override    public SharedPreferences.Editor putInt(String key, int value) {      mTransactions.add(new IntegerTransactionItem(key, value));      return this;    }    @Override    public SharedPreferences.Editor putLong(String key, long value) {      mTransactions.add(new LongTransactionItem(key, value));      return this;    }    @Override    public SharedPreferences.Editor putFloat(String key, float value) {      mTransactions.add(new FloatTransactionItem(key, value));      return this;    }    @Override    public SharedPreferences.Editor putBoolean(String key, boolean value) {      mTransactions.add(new BooleanTransactionItem(key, value));      return this;    }    @Override    public SharedPreferences.Editor remove(String key) {      mTransactions.add(forRemove(key));      return this;    }    @Override    public SharedPreferences.Editor clear() {      // TODO: 2017/7/1 foreach      return this;    }    @Override    public boolean commit() {      boolean success = doCommit();      if (!success) {        doRevert();      }      init();      return success;    }    private void doRevert() {      for (TranscationItem transcationItem : mTransactions) {        transcationItem.revert(obtainEditor(transcationItem.key));      }      for (Editor editor : mEditorCache.values()) {        editor.commit();      }    }    private boolean doCommit() {      for (TranscationItem transcationItem : mTransactions) {        transcationItem.commit(obtainEditor(transcationItem.key));      }      boolean success = true;      for (Editor editor : mEditorCache.values()) {        success &= editor.commit();      }      return success;    }    @Override    public void apply() {      new Thread() {        @Override        public void run() {          super.run();          commit();        }      }.start();    }  }  private abstract class TranscationItem<T> {    public String key;    private Pair<T, T> mData;    public TranscationItem(String key, T to) {      this.key = key;      T from = oldValue();      mData = new Pair<>(from, to);    }    public void commit(Editor editor) {      if (mData.second == null) {        editor.remove(key);      } else {        toEditor(editor, mData.second);      }    }    public void revert(Editor editor) {      if (mData.first == null) {        editor.remove(key);      } else {        toEditor(editor, mData.first);      }    }    protected abstract void toEditor(Editor editor, T value);    protected abstract T oldValue();  }  private class StringTransactionItem extends TranscationItem<String> {    public StringTransactionItem(String key, String to) {      super(key, to);    }    @Override    protected void toEditor(Editor editor, String value) {      editor.putString(key, value);    }    @Override    protected String oldValue() {      return mPreferenceConfig.preferenceForKey(key).getString(key, null);    }  }  private class IntegerTransactionItem extends TranscationItem<Integer> {    public IntegerTransactionItem(String key, Integer to) {      super(key, to);    }    @Override    protected void toEditor(Editor editor, Integer value) {      editor.putInt(key, value);    }    @Override    protected Integer oldValue() {      return mPreferenceConfig.preferenceForKey(key).getInt(key, 0);    }  }  private class LongTransactionItem extends TranscationItem<Long> {    public LongTransactionItem(String key, Long to) {      super(key, to);    }    @Override    protected void toEditor(Editor editor, Long value) {      editor.putLong(key, value);    }    @Override    protected Long oldValue() {      return mPreferenceConfig.preferenceForKey(key).getLong(key, 0);    }  }  private class FloatTransactionItem extends TranscationItem<Float> {    public FloatTransactionItem(String key, Float to) {      super(key, to);    }    @Override    protected void toEditor(Editor editor, Float value) {      editor.putFloat(key, value);    }    @Override    protected Float oldValue() {      return mPreferenceConfig.preferenceForKey(key).getFloat(key, 0);    }  }  private class BooleanTransactionItem extends TranscationItem<Boolean> {    public BooleanTransactionItem(String key, Boolean to) {      super(key, to);    }    @Override    protected void toEditor(Editor editor, Boolean value) {      editor.putBoolean(key, value);    }    @Override    protected Boolean oldValue() {      return mPreferenceConfig.preferenceForKey(key).getBoolean(key, false);    }  }  private TranscationItem forRemove(String key) {    if (TextUtils.isEmpty(key) || !mPreferenceConfig.preferenceForKey(key).contains(key)) {      return null;    }    Object value = mPreferenceConfig.preferenceForKey(key).getAll().get(key);    if (value instanceof String) {      return new StringTransactionItem(key, null);    } else if (value instanceof Integer) {      return new IntegerTransactionItem(key, null);    } else if (value instanceof Long) {      return new LongTransactionItem(key, null);    } else if (value instanceof Float) {      return new FloatTransactionItem(key, null);    } else if (value instanceof Boolean) {      return new BooleanTransactionItem(key, null);    }    return null;  }}

public class PreferenceConfig {  private static final int PREFERENCE_SIZE = 10;  private static final String KEY_VERSION = "chp_version";  private String mPrefix = "Kwai_";  private SharedPreferences mNameMappings;  private SparseArray<String> mPreferencesMappings;  private Map<String, Integer> mHashMappings;  private Map<String, SharedPreferences> mPreferences = new HashMap<>();  private Context mContext;  private int mVersion;  public PreferenceConfig(String prefix, String configName, Context context,      SparseArray<String> preferencesMappings,      Map<String, Integer> hashMappings, int version) {    mPrefix = prefix;    mNameMappings = context.getSharedPreferences(mPrefix + configName, Context.MODE_PRIVATE);    mPreferencesMappings = genPreferencesMappings(preferencesMappings);    mHashMappings = hashMappings;    mVersion = version;    mContext = context;    checkAndUpgrade();  }  @NonNull  private SparseArray<String> genPreferencesMappings(SparseArray<String> preferencesMappings) {    SparseArray<String> mappings =        preferencesMappings == null ? new SparseArray<String>() : preferencesMappings;    String last = null;    int firstIndex = 0;    for (int i = 0; i < PREFERENCE_SIZE; ++i) {      if (!TextUtils.isEmpty(last = mappings.get(i))) {        firstIndex = i;        break;      }    }    if (TextUtils.isEmpty(last)) {      last = mPrefix;    }    for (int i = PREFERENCE_SIZE + firstIndex; i > firstIndex; --i) {      if (TextUtils.isEmpty(mappings.get((i - 1) % PREFERENCE_SIZE))) {        mappings.put((i - 1) % PREFERENCE_SIZE, last);      } else {        last = mappings.get((i - 1) % PREFERENCE_SIZE);      }    }    return mappings;  }  private String nameForIndex(int i) {    String name = mPreferencesMappings.get(i);    return TextUtils.isEmpty(name) ? mPrefix : name;  }  int hashForKey(String key) {    if (mHashMappings == null) {      return key.hashCode();    }    Integer mapping = mHashMappings.get(key);    return mapping == null ? key.hashCode() : mapping;  }  SharedPreferences preferenceForKey(String key) {    int hash = hashForKey(key);    String name = nameForIndex(hash);    return getSharedPreferencesByName(name);  }  private SharedPreferences getSharedPreferencesByName(String name) {    if (mPreferences.get(name) == null) {      mPreferences.put(name, mContext          .getSharedPreferences(name, Context.MODE_MULTI_PROCESS));    }    return mPreferences.get(name);  }  private void checkAndUpgrade() {    int oldVersion = mNameMappings.getInt(KEY_VERSION, 0);    if (mVersion <= oldVersion) {      mPreferencesMappings = new SparseArray<>();      for (int i = 0; i < PREFERENCE_SIZE; ++i) {        mPreferencesMappings.put(i, mNameMappings.getString(String.valueOf(i), null));      }      return;    }    // 迁移sp    if (!transferSp()) {      return;    }    // 迁移group    if (!transferGroup()) {      return;    }    commitVersion();  }  private boolean commitVersion() {    SharedPreferences.Editor editor = mNameMappings.edit();    editor.putInt(KEY_VERSION, mVersion);    for (int i = 0; i < PREFERENCE_SIZE; ++i) {      editor.putString(String.valueOf(i), mPreferencesMappings.get(i));    }    return editor.commit();  }  private boolean transferGroup() {    // 尽量减少commit次数，重复缓存了很多东西    HashMap<String, Map<String, ?>> oldDataCache = new HashMap<>();    HashMap<String, Set<String>> toRemove = new HashMap<>();    HashMap<String, Map<String, Object>> toAdd = new HashMap<>();    for (String key : mHashMappings.keySet()) {      if (preferenceForKey(key).contains(key)) {        continue;      }      String oldName = nameForIndex(key.hashCode());      if (oldDataCache.get(oldName) == null) {        oldDataCache.put(oldName, preferenceForKey(oldName).getAll());      }      String newName = nameForIndex(hashForKey(key));      if (toAdd.get(newName) == null) {        toAdd.put(newName, new HashMap<String, Object>());      }      toAdd.get(newName).put(key, oldDataCache.get(oldName).get(key));      if (toRemove.get(oldName) == null) {        toRemove.put(oldName, new HashSet<String>());      }      toRemove.get(oldName).add(key);    }    boolean success = true;    for (String name : toAdd.keySet()) {      SharedPreferences.Editor editor = getSharedPreferencesByName(name).edit();      Map<String, Object> data = toAdd.get(name);      for (String key : data.keySet()) {        putByType(editor, key, data.get(key));      }      success &= editor.commit();    }    if (!success) {      return false;    }    for (String name : toRemove.keySet()) {      SharedPreferences.Editor editor = getSharedPreferencesByName(name).edit();      Set<String> keys = toRemove.get(name);      for (String key : keys) {        editor.remove(key);      }      success &= editor.commit();    }    return success;  }  private boolean transferSp() {    // 目标sp只会对应到一个源sp    HashMap<String, String> transferMapping = new HashMap<>();    for (int i = 0; i < PREFERENCE_SIZE; ++i) {      String oldName = mNameMappings.getString(String.valueOf(i), null);      String name = mPreferencesMappings.get(i);      if (!TextUtils.equals(oldName, name)) {        // 不同sp        if (oldName == null) {          oldName = mPrefix;        }        transferMapping.put(name, oldName);      }    }    boolean success = true;    for (String newName : transferMapping.keySet()) {      Set<String> toRemove = new HashSet<>();      SharedPreferences oldPreferences = getSharedPreferencesByName(transferMapping.get(newName));      Map<String, ?> oldData = oldPreferences.getAll();      SharedPreferences.Editor oldEditor = oldPreferences.edit();      SharedPreferences.Editor newEditor = getSharedPreferencesByName(newName).edit();      for (String key : oldData.keySet()) {        if (TextUtils.equals(nameForIndex(hashForKey(key)), newName)) {          toRemove.add(key);          putByType(newEditor, key, oldData.get(key));        }      }      if (newEditor.commit()) {        for (String key : toRemove) {          oldEditor.remove(key);        }        success &= oldEditor.commit();      } else {        success = false;      }    }    return success;  }  private void putByType(SharedPreferences.Editor editor, String key, Object value) {    if (TextUtils.isEmpty(key) || value == null) {      return;    }    if (value instanceof String) {      editor.putString(key, (String) value);    } else if (value instanceof Integer) {      editor.putInt(key, (Integer) value);    } else if (value instanceof Long) {      editor.putLong(key, (Long) value);    } else if (value instanceof Float) {      editor.putFloat(key, (Float) value);    } else if (value instanceof Boolean) {      editor.putBoolean(key, (Boolean) value);    }  }  public Collection<SharedPreferences> all() {    return mPreferences.values();  }}

ConsistentHash算法就不用多说了，用在sp上的坑也是有的：

• 升级和分块的控制，即具体sp实体放到哪个hashcode。此处仿照DB的version思路。
• commit的原子性。一次edit到commit之间的所有操作应该是一个transaction。使用了command模式。这里是性能瓶颈，出现了太多的额外对象创建和Map扩展。最终导致了悲剧。

最后做了性能测试，发现一致性哈希完败。千行数据，只有在单行超30字符的时候，读取能够持平；写入有百倍的劣化。而且，最尴尬的是，sp本身的数据相当亮眼，并没有优化的意义。这么尴尬的事情，记录一下吧。