/**
* Constructs a new map containing the same elements and using the same ordering as the specified
* sorted map.
*
* @param max Upper bound of this map.
* @param map Sorted map whose elements will comprise the new map.
* @throws NullPointerException if the specified sorted map or any of its elements are {@code
* null}.
*/
public GridBoundedConcurrentOrderedMap(int max, SortedMap<K, V> map) {
super(map);
A.ensure(max > 0, "max > 0");
this.max = max;
}
/**
* Constructs a new, empty set that orders its elements according to the specified comparator.
*
* @param max Upper bound of this map.
* @param comparator The comparator that will be used to order this map. If <tt>null</tt>, the
* {@linkplain Comparable natural ordering} of the elements will be used.
*/
public GridBoundedConcurrentOrderedMap(int max, Comparator<? super K> comparator) {
super(comparator);
A.ensure(max > 0, "max > 0");
this.max = max;
}
/**
* Constructs a new map containing the elements in the specified map, that orders its elements
* according to their {@linkplain Comparable natural ordering}.
*
* @param max Upper bound of this map.
* @param map The elements that will comprise the new map.
* @throws ClassCastException if the elements in <tt>map</tt> are not {@link Comparable}, or are
* not mutually comparable.
* @throws NullPointerException if the specified map or any of its elements are {@code null}.
*/
public GridBoundedConcurrentOrderedMap(int max, Map<? extends K, ? extends V> map) {
super(map);
A.ensure(max > 0, "max > 0");
this.max = max;
}
/**
* Gets option value. If this option is "none" this method will throw {@link
* IllegalArgumentException} exception. Note that this method may return {@code null}.
*
* @return An option value.
* @throws IllegalArgumentException Thrown in case if this option is "none".
*/
public T get() {
A.ensure(this != NONE, "Value 'none' of GridOpt cannot be used.");
assert val != null;
return val;
}
/**
* Set local batch size for this sequences.
*
* @param size Sequence batch size. Must be more then 0.
*/
@Override
public void batchSize(int size) {
A.ensure(size > 0, " Batch size can't be less then 0: " + size);
lock.lock();
try {
batchSize = size;
} finally {
lock.unlock();
}
}
/** {@inheritDoc} */
@Override
public void saveCheckpoint(
String key, Object state, GridTaskSessionScope scope, long timeout, boolean overwrite)
throws GridException {
A.notNull(key, "key");
A.ensure(timeout >= 0, "timeout >= 0");
synchronized (mux) {
if (closed) throw new GridException("Failed to save checkpoint (session closed): " + this);
}
ctx.checkpoint().storeCheckpoint(this, key, state, scope, timeout, overwrite);
}
/** {@inheritDoc} */
@Override
public R get(long timeout, TimeUnit unit) throws GridException {
A.ensure(timeout >= 0, "timeout cannot be negative: " + timeout);
A.notNull(unit, "unit");
checkValid();
try {
long now = System.currentTimeMillis();
long end = timeout == 0 ? Long.MAX_VALUE : now + MILLISECONDS.convert(timeout, unit);
// Account for overflow.
if (end < 0) end = Long.MAX_VALUE;
synchronized (mux) {
while (!done && !cancelled && now < end) {
mux.wait(end - now);
if (!done) now = System.currentTimeMillis();
}
if (done) {
if (err != null) throw U.cast(err);
return res;
}
if (cancelled) throw new GridFutureCancelledException("Future was cancelled: " + this);
throw new GridFutureTimeoutException(
"Timeout was reached before computation completed [duration="
+ duration()
+ "ms, timeout="
+ unit.toMillis(timeout)
+ "ms]");
}
} catch (InterruptedException e) {
throw new GridInterruptedException(
"Got interrupted while waiting for future to complete [duration="
+ duration()
+ "ms, timeout="
+ unit.toMillis(timeout)
+ "ms]",
e);
}
}
/**
* Constructs a new, empty map that orders its elements according to their {@linkplain Comparable
* natural ordering}.
*
* @param max Upper bound of this map.
*/
public GridBoundedConcurrentOrderedMap(int max) {
A.ensure(max > 0, "max > 0");
this.max = max;
}
/**
* Asynchronous sequence update operation. Will add given amount to the sequence value.
*
* @param l Increment amount.
* @param updateCall Cache call that will update sequence reservation count in accordance with l.
* @param updated If {@code true}, will return sequence value after update, otherwise will return
* sequence value prior to update.
* @return Future indicating sequence value.
* @throws GridException If update failed.
*/
private GridFuture<Long> internalUpdateAsync(
long l, @Nullable Callable<Long> updateCall, boolean updated) throws GridException {
checkRemoved();
A.ensure(l > 0, " Parameter mustn't be less then 1: " + l);
lock.lock();
try {
// If reserved range isn't exhausted.
if (locVal + l <= upBound) {
long curVal = locVal;
locVal += l;
return new GridFinishedFuture<Long>(ctx.kernalContext(), updated ? locVal : curVal);
}
} finally {
lock.unlock();
}
if (updateCall == null) updateCall = internalUpdate(l, updated);
while (true) {
if (updateGuard.compareAndSet(false, true)) {
try {
// This call must be outside lock.
return ctx.closures().callLocalSafe(updateCall, true);
} finally {
lock.lock();
try {
updateGuard.set(false);
cond.signalAll();
} finally {
lock.unlock();
}
}
} else {
lock.lock();
try {
while (locVal >= upBound && updateGuard.get()) {
try {
cond.await(500, MILLISECONDS);
} catch (InterruptedException e) {
throw new GridInterruptedException(e);
}
}
checkRemoved();
// If reserved range isn't exhausted.
if (locVal + l <= upBound) {
long curVal = locVal;
locVal += l;
return new GridFinishedFuture<Long>(ctx.kernalContext(), updated ? locVal : curVal);
}
} finally {
lock.unlock();
}
}
}
}
/** {@inheritDoc} */
@Override
public GridFuture<Long> getAndAddAsync(long l) throws GridException {
A.ensure(l > 0, " Parameter mustn't be less then 1: " + l);
return internalUpdateAsync(l, null, false);
}
/** {@inheritDoc} */
@Override
public long addAndGet(long l) throws GridException {
A.ensure(l > 0, " Parameter mustn't be less then 1: " + l);
return internalUpdate(l, null, true);
}
/** {@inheritDoc} */
@Override
public int countDown(int val) throws GridException {
A.ensure(val > 0, "val should be positive");
return CU.outTx(new CountDownCallable(val), ctx);
}
/**
* Gets value at given index within internal list. Note that this method will iterate through the
* list to get a value at the specified index.
*
* @param idx Index to get value at (must be non-negative and less than {@link #size()}).
* @return Value at give index.
*/
public V get(int idx) {
A.ensure(idx >= 0 && idx < size(), "idx >= 0 && idx < size()");
return vals.get(idx);
}