This class may be removed in the future. Consider the replacements in JEP 193 'Variable Handles': http://openjdk.java.net/jeps/193
@Override public void lazySet(U obj, M newValue) { unsafe.putOrderedObject(obj, offset, newValue); }
/** * An ordered store(store + StoreStore barrier) of an element to a given offset * * @param buffer this.buffer * @param offset computed via {@link UnsafeRefArrayAccess#calcElementOffset} * @param e an orderly kitty */ public static <E> void soElement(E[] buffer, long offset, E e) { UNSAFE.putOrderedObject(buffer, offset, e); }
void lazySetTail(Node<E> next) { UnsafeAccess.UNSAFE.putOrderedObject(this, TAIL_OFFSET, next); }
final void soBlocked(Thread thread) { UNSAFE.putOrderedObject(this, BLOCKED_OFFSET, thread); } }
/** * An ordered store(store + StoreStore barrier) of an element to a given offset * * @param buffer this.buffer * @param offset computed via {@link UnsafeRefArrayAccess#calcElementOffset} * @param e an orderly kitty */ public static <E> void soElement(E[] buffer, long offset, E e) { UNSAFE.putOrderedObject(buffer, offset, e); }
/** * Sets next field with volatile write semantics. (See above * about use of putOrderedObject.) */ final void setNext(HashEntry<K,V> n) { UNSAFE.putOrderedObject(this, nextOffset, n); }
/** * Sets the ith element of given table, with volatile write * semantics. (See above about use of putOrderedObject.) */ static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i, HashEntry<K,V> e) { UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e); }
/** * Eventually sets to the given value. * * @param newValue the new value * @since 1.6 */ public final void lazySet(V newValue) { unsafe.putOrderedObject(this, valueOffset, newValue); }
void lazySetPrev(Node<E> val) { UNSAFE.putOrderedObject(this, prevOffset, val); }
void lazySetNext(Node<E> val) { UNSAFE.putOrderedObject(this, nextOffset, val); }
void lazySetPrev(Node<E> val) { UNSAFE.putOrderedObject(this, prevOffset, val); }
void lazySetPrev(Node<E> val) { UNSAFE.putOrderedObject(this, prevOffset, val); }
public void soNext(LinkedQueueNode<E> n) { UNSAFE.putOrderedObject(this, NEXT_OFFSET, n); }
void lazySetNext(@Nullable Node<E> newNext) { UnsafeAccess.UNSAFE.putOrderedObject(this, NEXT_OFFSET, newNext); }
void setRelaxedObject(Object value) { UnsafeAccess.UNSAFE.putOrderedObject(this, MoreRelaxedFields.OVALUE_OFFSET, value); }
/** * Eventually sets the element at position {@code i} to the given value. * * @param i the index * @param newValue the new value * @since 1.6 */ public final void lazySet(int i, E newValue) { unsafe.putOrderedObject(array, checkedByteOffset(i), newValue); }
public void lazySet(T obj, V newValue) { if (obj == null || obj.getClass() != tclass || cclass != null || (newValue != null && vclass != null && vclass != newValue.getClass())) updateCheck(obj, newValue); unsafe.putOrderedObject(obj, offset, newValue); }
public ManyToOneConcurrentLinkedQueue() { headOrdered(empty); UNSAFE.putOrderedObject(this, TAIL_OFFSET, empty); }
public E poll() { if (head >= batchHead) { if (!backtrackPoll()) { return null; } } final long offset = offset(head); @SuppressWarnings("unchecked") final E e = (E) UNSAFE.getObject(buffer, offset); UNSAFE.putOrderedObject(buffer, offset, null); head++; return e; }
@Override public int offer(E e) { long head = readCounter; long tail = relaxedWriteCounter(); long size = (tail - head); if (size >= SPACED_SIZE) { return FULL; } if (casWriteCounter(tail, tail + OFFSET)) { long offset = ((tail & SPACED_MASK) << SHIFT) + BASE; UnsafeAccess.UNSAFE.putOrderedObject(buffer, offset, e); return SUCCESS; } return FAILED; }