public class MyConcurrentQueue<T> {
private volatile Node<T> head;
private volatile Node<T> tail;
public void enqueue(T item) {
Node<T> newNode = new Node<>(item);
if (head == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
tail = newNode;
}
}
private static class Node<T> {
private final T item;
private volatile Node<T> next;
public Node(T item) {
this.item = item;
}
}
}
import java.util.concurrent.atomic.AtomicReference;
public class MyConcurrentQueue<T> {
private AtomicReference<Node<T>> head;
private AtomicReference<Node<T>> tail;
public void enqueue(T item) {
Node<T> newNode = new Node<>(item);
while (true) {
Node<T> curTail = tail.get();
Node<T> tailNext = curTail.next.get();
if (curTail == tail.get()) {
if (tailNext == null) {
if (curTail.next.compareAndSet(null, newNode)) {
tail.compareAndSet(curTail, newNode);
return;
}
} else {
tail.compareAndSet(curTail, tailNext);
}
}
}
}
private static class Node<T> {
private final T item;
private AtomicReference<Node<T>> next;
public Node(T item) {
this.item = item;
this.next = new AtomicReference<>(null);
}
}
}
import java.util.concurrent.atomic.AtomicReference;
public class MyConcurrentQueue<T> {
private static final int INITIAL_CAPACITY = 1024;
private AtomicReference<T[]> elements;
private volatile int head;
private volatile int tail;
@SuppressWarnings("unchecked")
public MyConcurrentQueue() {
this.elements = new AtomicReference<>((T[]) new Object[INITIAL_CAPACITY]);
this.head = 0;
this.tail = 0;
}
public void enqueue(T item) {
T currentItem = elements.getAndSet(tail, item);
tail++;
if (tail == elements.length) {
expandCapacity();
}
}
private void expandCapacity() {
T[] oldElements = elements.get();
T[] newElements = (T[]) new Object[oldElements.length * 2];
System.arraycopy(oldElements, 0, newElements, 0, oldElements.length);
elements.set(newElements);
}
}
import java.util.concurrent.atomic.AtomicReference;
public class MyConcurrentQueue<T> {
private static final int CACHE_LINE_SIZE = 64;
private AtomicReference<Node<T>> head;
private Node<T> tail;
public void enqueue(T item) {
Node<T> newNode = new Node<>(item);
Node<T> localTail = tail;
Node<T> localNext = localTail.next;
if (localNext != null) {
tail = localNext;
} else {
localTail.next = newNode;
tail = newNode;
}
}
private static class Node<T> {
private final T item;
private Node<T> next;
}
}
