Thoughts on adding ConcurrentMap methods to StoredMap?

Question

as far as i can tell, StoredMap has the potential to implement the extra methods in the jdk 1.5 ConcurrentMap interface. Database already has a putNoOverwrite method which would be the implementation of putIfAbsent. Personally, however, i am more interested in the other methods, all of which basically do their work only if the current value matches a given old value. this enables safe concurrent updates to a StoredMap even outside of transactions, basically using an optimistic scenario:
- read existing key,value (hold no locks)
- copy current value and modify the copy
- write modified value only if current value matches what is now in the database (this line within the context of a RMW lock)
any idea if this could be incorporated in the je codebase anytime soon? i may end up implementing it in our codebase, although the je api is not easy to extend as most classes/useful methods are package protected (arg!).

Answer 1

hey,
just wanted to follow up on this a little. after using the concurrent implementation for a while (with transactions enabled), i experimented with extending the api to add a "transaction-like" extension to the concurrentmap api. this basically blends the concurrentmap api with the option of better performance when transactions are enabled in the underlying bdb. there are three methods added, which basically allow for "locking" a given key and "committing" or "rolling back" the updates as appropriate (if transactions are not enabled, the new methods are largely no-ops, and you get normal concurrent map behavior). thought i'd post the new code in case you were interested in providing this facility to other users (or, you could just stick with the original version posted above).
Example usage:
Object key;
try {
  Object value = map.getForUpdate(key);
  // ... run concurrent ops on value ...
  map.replace(key, value, newValue);
  map.completeUpdate(key);
} finally {
  map.closeUpdate(key);
}New implementation:
public class StoredConcurrentMap extends StoredMap
  private final ThreadLocal<UpdateState> _updateState =
    new ThreadLocal<UpdateState>();
  public StoredConcurrentMap(
      Database database, EntryBinding keyBinding,
      EntryBinding valueEntityBinding, boolean writeAllowed)
    super(database, keyBinding, valueEntityBinding, writeAllowed);
  public Object getForUpdate(Object key)
    if(_updateState.get() != null) {
      throw new IllegalStateException(
          "previous update still outstanding for key " +
          _updateState.get()._key);
    UpdateState updateState = new UpdateState(key, beginAutoCommit());
    _updateState.set(updateState);
    DataCursor cursor = null;
    Object value = null;
    try {
      cursor = new DataCursor(view, true, key);
      if(OperationStatus.SUCCESS == cursor.getNextNoDup(true)) {
        // takeover ownership of the cursor
        value = updateState.loadCurrentValue(cursor);
        cursor = null;
      closeCursor(cursor);
    } catch (Exception e) {
      closeCursor(cursor);
      throw handleException(e, false);
    return value;
  public void completeUpdate(Object key)
    UpdateState updateState = getUpdateState(key);
    if(updateState != null) {
      try {
        updateState.clearCurrentValue(this);
        commitAutoCommit(updateState._doAutoCommit);
        // only clear the reference if everything succeeds
        _updateState.set(null);
      } catch(DatabaseException e) {
        throw new RuntimeExceptionWrapper(e);
  public void closeUpdate(Object key)
    UpdateState updateState = getUpdateState(key);
    if(updateState != null) {
      // this op failed, abort (clear the reference regardless of what happens
      // below)
      _updateState.set(null);
      try {
        updateState.clearCurrentValue(this);
        view.getCurrentTxn().abortTransaction();
      } catch(DatabaseException ignored) {
  public Object putIfAbsent(Object key, Object value)
    UpdateState updateState = getUpdateState(key);
    if(valueExists(updateState)) {
      return updateState._curValue;
    Object oldValue = null;
    DataCursor cursor = null;
    boolean doAutoCommit = beginAutoCommit();
    try {
      cursor = new DataCursor(view, true);
      while(true) {
        if(OperationStatus.SUCCESS ==
           cursor.putNoOverwrite(key, value, false)) {
          // we succeeded
          break;
        } else if(OperationStatus.SUCCESS ==
                  cursor.getSearchKey(key, null, false)) {
          // someone else beat us to it
          oldValue = cursor.getCurrentValue();
          break;
        // we couldn't put and we couldn't get, try again
      closeCursor(cursor);
      commitAutoCommit(doAutoCommit);
    } catch (Exception e) {
      closeCursor(cursor);
      throw handleException(e, doAutoCommit);
    return oldValue;
  public boolean remove(Object key, Object value)
    UpdateState updateState = getUpdateState(key);
    if(valueExists(updateState)) {
      if(ObjectUtils.equals(updateState._curValue, value)) {
        try {
          updateState._cursor.delete();
          updateState.clearCurrentValue(this);
          return true;
        } catch (Exception e) {
          throw handleException(e, false);
      } else {
        return false;
    boolean removed = false;
    DataCursor cursor = null;
    boolean doAutoCommit = beginAutoCommit();
    try {
      cursor = new DataCursor(view, true, key);
      if(OperationStatus.SUCCESS == cursor.getNextNoDup(true)) {
        Object curValue = cursor.getCurrentValue();
        if(ObjectUtils.equals(curValue, value)) {
          cursor.delete();
          removed = true;
      closeCursor(cursor);
      commitAutoCommit(doAutoCommit);
    } catch (Exception e) {
      closeCursor(cursor);
      throw handleException(e, doAutoCommit);
    return removed;
  public boolean replace(Object key, Object oldValue, Object newValue)
    UpdateState updateState = getUpdateState(key);
    if(valueExists(updateState)) {
      if(ObjectUtils.equals(updateState._curValue, oldValue)) {
        try {
          updateState.replaceCurrentValue(newValue);
          return true;
        } catch (Exception e) {
          throw handleException(e, false);
      } else {
        return false;
    boolean replaced = false;
    DataCursor cursor = null;
    boolean doAutoCommit = beginAutoCommit();
    try {
      cursor = new DataCursor(view, true, key);
      if(OperationStatus.SUCCESS == cursor.getNextNoDup(true)) {
        Object curValue = cursor.getCurrentValue();
        if(ObjectUtils.equals(curValue, oldValue)) {
          cursor.putCurrent(newValue);
          replaced = true;
      closeCursor(cursor);
      commitAutoCommit(doAutoCommit);
    } catch (Exception e) {
      closeCursor(cursor);
      throw handleException(e, doAutoCommit);
    return replaced;
  public Object replace(Object key, Object value)
    UpdateState updateState = getUpdateState(key);
    if(valueExists(updateState)) {
      try {
        return updateState.replaceCurrentValue(value);
      } catch (Exception e) {
        throw handleException(e, false);
    Object curValue = null;
    DataCursor cursor = null;
    boolean doAutoCommit = beginAutoCommit();
    try {
      cursor = new DataCursor(view, true, key);
      if(OperationStatus.SUCCESS == cursor.getNextNoDup(true)) {
        curValue = cursor.getCurrentValue();
        cursor.putCurrent(value);
      closeCursor(cursor);
      commitAutoCommit(doAutoCommit);
    } catch (Exception e) {
      closeCursor(cursor);
      throw handleException(e, doAutoCommit);
    return curValue;
   * @return the current UpdateState for the given key, if any, {@code null}
   *         otherwise.
  private UpdateState getUpdateState(Object key)
    UpdateState updateState = _updateState.get();
    if((updateState != null) && (ObjectUtils.equals(updateState._key, key))) {
      return updateState;
    return null;
   * @return {@code true} if the update state exists and found a value (which
   *         is currently locked)
  private boolean valueExists(UpdateState updateState)
    return((updateState != null) && (updateState._cursor != null));
   * Maintains state about an object loaded in a
   * {@link StoredConcurrentMap#getForUpdate} call.
  private static class UpdateState
    public final Object _key;
    public final boolean _doAutoCommit;
    public DataCursor _cursor;
    public Object _curValue;
    private UpdateState(Object key, boolean doAutoCommit) {
      _key = key;
      _doAutoCommit = doAutoCommit;
     * Loads the current value from the given cursor, and maintains a
     * reference to the given cursor and the loaded value.
    public Object loadCurrentValue(DataCursor cursor)
      throws DatabaseException
      _cursor = cursor;
      _curValue = _cursor.getCurrentValue();
      return _curValue;
     * Replaces the current value in the current cursor with the given value.
     * @return the old value
    public Object replaceCurrentValue(Object newValue)
      throws DatabaseException
      Object oldValue = _curValue;
      _cursor.putCurrent(newValue);
      _curValue = newValue;
      return oldValue;
     * Closes the current curstor and clears the references to the cursor and
     * current value.
    public void clearCurrentValue(StoredConcurrentMap map) {
      try {
        map.closeCursor(_cursor);
      } finally {
        _cursor = null;
        _curValue = null;
}