138 lines
3.0 KiB
Java
138 lines
3.0 KiB
Java
package pp;
|
|
|
|
import java.util.concurrent.locks.Lock;
|
|
import java.util.concurrent.locks.ReentrantLock;
|
|
|
|
import net.jcip.annotations.ThreadSafe;
|
|
|
|
@ThreadSafe
|
|
public class ThreadsafeSimplifiedList<T> implements SimplifiedList<T> {
|
|
private Node<T> first;
|
|
private final Lock listLock = new ReentrantLock();
|
|
|
|
private class Node<U> {
|
|
private U element;
|
|
private Node<U> prev;
|
|
private Node<U> next;
|
|
private final Lock lock = new ReentrantLock();
|
|
|
|
private Node(U element, Node<U> prev, Node<U> next) {
|
|
super();
|
|
this.element = element;
|
|
this.prev = prev;
|
|
this.next = next;
|
|
}
|
|
}
|
|
|
|
public ThreadsafeSimplifiedList() {
|
|
super();
|
|
this.first = null;
|
|
}
|
|
|
|
/**
|
|
* Returns the element at the specified position in this list.
|
|
*
|
|
* @param index index of the element to return
|
|
* @return the element at the specified position in this list
|
|
*/
|
|
@Override
|
|
public T get(int index) {
|
|
this.listLock.lock();
|
|
var ptr = this.first;
|
|
ptr.lock.lock();
|
|
this.listLock.unlock();
|
|
for (var j = 0; j < index; j++) {
|
|
if (ptr.next != null) {
|
|
ptr.next.lock.lock();
|
|
var savePtr = ptr;
|
|
ptr = ptr.next;
|
|
savePtr.lock.unlock();
|
|
} else {
|
|
throw new IndexOutOfBoundsException(index + " out of bounds");
|
|
}
|
|
}
|
|
try {
|
|
return (ptr.element);
|
|
}
|
|
finally {
|
|
ptr.lock.unlock();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Appends the specified element to the end of this list. There are no
|
|
* limitations on what elements may be added to this list.
|
|
*
|
|
* @param element element to be appended to this list
|
|
* @return true
|
|
* @see java.util.Collection#add(Object)
|
|
*
|
|
*/
|
|
@Override
|
|
public boolean add(T element) {
|
|
this.listLock.lock();
|
|
if (this.first != null) {
|
|
var ptr = this.first;
|
|
ptr.lock.lock();
|
|
this.listLock.unlock();
|
|
while (ptr.next != null) {
|
|
ptr.next.lock.lock();
|
|
var saveNode = ptr;
|
|
ptr = ptr.next;
|
|
saveNode.lock.unlock();
|
|
}
|
|
ptr.next = new Node<>(element, ptr, null);
|
|
} else {
|
|
this.first = new Node<>(element, null, null);
|
|
this.listLock.unlock();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Replaces the element at the specified position in this list with the
|
|
* specified element.
|
|
*
|
|
* @param index index of the element to replace
|
|
* @param element element to be stored at the specified position
|
|
* @return the element previously at the specified position
|
|
*/
|
|
@Override
|
|
public T set(int index, T element) {
|
|
this.listLock.lock();
|
|
var ptr = this.first;
|
|
ptr.lock.lock();
|
|
this.listLock.unlock();
|
|
for (var j = 0; j < index; j++) {
|
|
if (ptr.next != null) {
|
|
ptr.next.lock.lock();
|
|
var saveNode = ptr;
|
|
ptr = ptr.next;
|
|
saveNode.lock.unlock();
|
|
} else {
|
|
throw new IndexOutOfBoundsException(index + " out of bounds");
|
|
}
|
|
}
|
|
var prevElement = ptr.element;
|
|
ptr.element = element;
|
|
ptr.lock.unlock();
|
|
return prevElement;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this list contains no elements.
|
|
*
|
|
* @return true if this list contains no elements
|
|
*/
|
|
@Override
|
|
public boolean isEmpty() {
|
|
this.listLock.lock();
|
|
try {
|
|
return this.first == null;
|
|
} finally {
|
|
this.listLock.unlock();
|
|
}
|
|
}
|
|
}
|
|
|