3009594
/
PP_SL
2
1
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity

Update

SL_U2_SJ
Obai Albek 2025-05-23 14:52:55 +02:00
parent bde868ad47
commit f015770a77
1 changed files with 132 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

218
pp.A4-HandOverHandLocking/src/main/java/pp/ThreadsafeSimplifiedList.java
View File

@ -1,97 +1,143 @@
package pp; package pp;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import lombok.Synchronized;
import net.jcip.annotations.ThreadSafe;
@ThreadSafe
public class ThreadsafeSimplifiedList<T> implements SimplifiedList<T> { public class ThreadsafeSimplifiedList<T> implements SimplifiedList<T> {
private Node<T> first; private Node<T> first;
private final Object headLock = new Object(); private final Lock listLock = new ReentrantLock();
private static class Node<U> { private class Node<U> {
U element; private U element;
Node<U> prev; private Node<U> prev;
Node<U> next; private Node<U> next;
final Object lock = new Object(); private final Lock lock = new ReentrantLock();
Node(U element, Node<U> prev, Node<U> next) { private Node(U element, Node<U> prev, Node<U> next) {
this.element = element; super();
this.prev = prev; this.element = element;
this.next = next; this.prev = prev;
} this.next = next;
} }
}
public ThreadsafeSimplifiedList() { public ThreadsafeSimplifiedList() {
this.first = null; super();
} this.first = null;
}
@Override /**
public boolean add(T element) { * Returns the element at the specified position in this list.
Node<T> curr; *
* @param index index of the element to return
* @return the element at the specified position in this list
*/
@Override
@Synchronized
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 {
return null;
}
ptr = ptr.next;
}
try {
return (ptr.element);
}
finally {
ptr.lock.unlock();
}
}
synchronized (headLock) { /**
if (first == null) { * Appends the specified element to the end of this list. There are no
first = new Node<>(element, null, null); * limitations on what elements may be added to this list.
return true; *
} * @param element element to be appended to this list
curr = first; * @return true
} * @see java.util.Collection#add(Object)
*
*/
@Override
@Synchronized
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;
}
while (true) { /**
Node<T> next; * Replaces the element at the specified position in this list with the
synchronized (curr.lock) { * specified element.
next = curr.next; *
if (next == null) { * @param index index of the element to replace
curr.next = new Node<>(element, curr, null); * @param element element to be stored at the specified position
return true; * @return the element previously at the specified position
} */
} @Override
curr = next; @Synchronized
} public T set(int index, T element) {
} this.listLock.lock();
var ptr = this.first;
ptr.lock.lock();
this.listLock.lock();
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 {
return null;
}
}
var prevElement = ptr.element;
ptr.element = element;
ptr.lock.unlock();
return prevElement;
}
@Override /**
public T get(int index) { * Returns true if this list contains no elements.
Node<T> curr; *
synchronized (headLock) { * @return true if this list contains no elements
if (first == null) throw new IndexOutOfBoundsException(); */
curr = first; @Override
} @Synchronized
public boolean isEmpty() {
synchronized (curr.lock) { this.listLock.lock();
for (int i = 0; i < index; i++) { try {
Node<T> next = curr.next; return this.first == null;
if (next == null) throw new IndexOutOfBoundsException(); } finally {
synchronized (next.lock) { this.listLock.unlock();
curr = next; }
} }
}
return delay(curr.element);
}
}
@Override
public T set(int index, T element) {
Node<T> curr;
synchronized (headLock) {
if (first == null) throw new IndexOutOfBoundsException();
curr = first;
}
synchronized (curr.lock) {
for (int i = 0; i < index; i++) {
Node<T> next = curr.next;
if (next == null) throw new IndexOutOfBoundsException();
synchronized (next.lock) {
curr = next;
}
}
T old = curr.element;
curr.element = element;
return old;
}
}
@Override
public boolean isEmpty() {
synchronized (headLock) {
return first == null;
}
}
} }