How to use

java.util.Collections$SynchronizedSortedMap

constructor

@Override public SortedMap<K, V> subMap(K startKey, K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.subMap(startKey,
        endKey), mutex);
  }
}

@Override public SortedMap<K, V> headMap(K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.headMap(endKey),
        mutex);
  }
}

@Override public SortedMap<K, V> tailMap(K startKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.tailMap(startKey),
        mutex);
  }
}

@Override public SortedMap<K, V> subMap(K startKey, K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.subMap(startKey,
        endKey), mutex);
  }
}

@Override public SortedMap<K, V> subMap(K startKey, K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.subMap(startKey,
        endKey), mutex);
  }
}

@Override public SortedMap<K, V> headMap(K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.headMap(endKey),
        mutex);
  }
}

public SortedMap<K,V> headMap(K toKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<>(sm.headMap(toKey), mutex);
  }
}
public SortedMap<K,V> tailMap(K fromKey) {

public SortedMap<K,V> subMap(K fromKey, K toKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<>(
      sm.subMap(fromKey, toKey), mutex);
  }
}
public SortedMap<K,V> headMap(K toKey) {

@Override public SortedMap<K, V> headMap(K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.headMap(endKey),
        mutex);
  }
}

@Override public SortedMap<K, V> subMap(K startKey, K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.subMap(startKey,
        endKey), mutex);
  }
}

@Override public SortedMap<K, V> tailMap(K startKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.tailMap(startKey),
        mutex);
  }
}

@Override public SortedMap<K, V> headMap(K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.headMap(endKey),
        mutex);
  }
}

public SortedMap<K,V> subMap(K fromKey, K toKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<>(
      sm.subMap(fromKey, toKey), mutex);
  }
}
public SortedMap<K,V> headMap(K toKey) {

@Override public SortedMap<K, V> headMap(K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.headMap(endKey),
        mutex);
  }
}

@Override public SortedMap<K, V> tailMap(K startKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.tailMap(startKey),
        mutex);
  }
}

@Override public SortedMap<K, V> tailMap(K startKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.tailMap(startKey),
        mutex);
  }
}

@Override public SortedMap<K, V> headMap(K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.headMap(endKey),
        mutex);
  }
}

@Override public SortedMap<K, V> tailMap(K startKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.tailMap(startKey),
        mutex);
  }
}

@Override public SortedMap<K, V> subMap(K startKey, K endKey) {
  synchronized (mutex) {
    return new SynchronizedSortedMap<K, V>(sm.subMap(startKey,
        endKey), mutex);
  }
}

/**
 * Returns a wrapper on the specified sorted map which synchronizes all
 * access to the sorted map.
 *
 * @param map
 *            the sorted map to wrap in a synchronized sorted map.
 * @return a synchronized sorted map.
 */
public static <K, V> SortedMap<K, V> synchronizedSortedMap(
    SortedMap<K, V> map) {
  if (map == null) {
    throw new NullPointerException("map == null");
  }
  return new SynchronizedSortedMap<K, V>(map);
}