Hand-over-Hand Locking (Java Concurrency Example)
Obai Albek
commit
ad92b64ce3
|
|
@ -0,0 +1,3 @@
|
|||
/target/
|
||||
/.classpath
|
||||
/.project
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
# Hand-over-Hand Locking (Java)
|
||||
|
||||
## 📌 Projektbeschreibung
|
||||
Dieses Projekt implementiert eine **Thread-sichere generische Liste** in Java mithilfe von **Hand-over-Hand Locking** (auch Lock Coupling genannt).
|
||||
Die Technik wird verwendet, um **Nebenläufigkeit (Concurrency)** zu ermöglichen und gleichzeitig eine feingranulare Synchronisation zu erreichen.
|
||||
|
||||
## ⚙️ Technologien
|
||||
- **Java 17+**
|
||||
- **Concurrency & Synchronisation (Locks, Threads)**
|
||||
- **Maven**
|
||||
|
||||
## ▶️ Ausführen
|
||||
1. Projekt mit Maven bauen:
|
||||
```bash
|
||||
mvn clean install
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<groupId>pp</groupId>
|
||||
<artifactId>pp.A4-HandOverHandLocking</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<properties>
|
||||
<exec.mainClass>pp.Main</exec.mainClass>
|
||||
<maven.compiler.release>10</maven.compiler.release>
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
</properties>
|
||||
<dependencies>
|
||||
<dependency><!-- für Unit-Tests -->
|
||||
<groupId>org.junit.jupiter</groupId>
|
||||
<artifactId>junit-jupiter</artifactId>
|
||||
<version>5.10.0</version>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
<dependency><!-- für Lombok -->
|
||||
<groupId>org.projectlombok</groupId>
|
||||
<artifactId>lombok</artifactId>
|
||||
<version>1.18.30</version>
|
||||
<scope>provided</scope>
|
||||
</dependency>
|
||||
<dependency><!-- für net.jcip Annotationen -->
|
||||
<groupId>net.jcip</groupId>
|
||||
<artifactId>jcip-annotations</artifactId>
|
||||
<version>1.0</version>
|
||||
<scope>provided</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
<build>
|
||||
<defaultGoal>clean compile exec:java</defaultGoal>
|
||||
<plugins>
|
||||
<plugin><!-- für Unit-Tests [mvn test] -->
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-surefire-plugin</artifactId>
|
||||
<version>3.0.0</version>
|
||||
</plugin>
|
||||
<plugin><!-- [mvn compile] -->
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-compiler-plugin</artifactId>
|
||||
<version>3.9.0</version>
|
||||
</plugin>
|
||||
<plugin><!-- [mvn exec:java] -->
|
||||
<groupId>org.codehaus.mojo</groupId>
|
||||
<artifactId>exec-maven-plugin</artifactId>
|
||||
<version>3.1.0</version>
|
||||
</plugin>
|
||||
<plugin><!-- [mvn javadoc:javadoc] -->
|
||||
<groupId>org.apache.maven.plugins</groupId>
|
||||
<artifactId>maven-javadoc-plugin</artifactId>
|
||||
<version>3.5.0</version>
|
||||
<configuration>
|
||||
<show>private</show>
|
||||
<locale>en_US</locale>
|
||||
</configuration>
|
||||
</plugin>
|
||||
</plugins>
|
||||
</build>
|
||||
</project>
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
package pp;
|
||||
|
||||
|
||||
public class Main {
|
||||
static SimplifiedList<Integer> list;
|
||||
|
||||
static Runnable sliceSum(int start, int end, int expected) {
|
||||
return () -> {
|
||||
var sum = 0;
|
||||
for (var i = start; i < end; i++) {
|
||||
sum += list.get(i);
|
||||
}
|
||||
if (sum != expected) {
|
||||
System.out.println("Fehler in "
|
||||
+ Thread.currentThread().getName() + ": " + sum);
|
||||
}else
|
||||
System.out.println("Kein Fehler in " + Thread.currentThread().getName() + ": " + sum);
|
||||
};
|
||||
}
|
||||
|
||||
public static void main(String... args) throws InterruptedException {
|
||||
list = new ThreadsafeSimplifiedList<>();
|
||||
for (int i = 0; i < 5000; i++) {
|
||||
list.add(i);
|
||||
}
|
||||
var thread0 = new Thread(sliceSum(0, 1250, 780625));
|
||||
var thread1 = new Thread(sliceSum(1250, 2500, 2343125));
|
||||
var thread2 = new Thread(sliceSum(2500, 3750, 3905625));
|
||||
var thread3 = new Thread(sliceSum(3750, 5000, 5468125));
|
||||
var start = System.currentTimeMillis();
|
||||
thread0.start();
|
||||
thread1.start();
|
||||
thread2.start();
|
||||
thread3.start();
|
||||
thread0.join();
|
||||
thread1.join();
|
||||
thread2.join();
|
||||
thread3.join();
|
||||
System.out.printf("%s: %d ms\n", list.getClass().toString(),
|
||||
System.currentTimeMillis() - start);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
package pp;
|
||||
|
||||
public interface SimplifiedList<T> {
|
||||
|
||||
/**
|
||||
* 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
|
||||
* @throws Exception
|
||||
*/
|
||||
public T get(int index);
|
||||
|
||||
/**
|
||||
* 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)
|
||||
*
|
||||
*/
|
||||
public boolean add(T element);
|
||||
|
||||
/**
|
||||
* 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
|
||||
* @throws Exception
|
||||
*/
|
||||
public T set(int index, T element);
|
||||
|
||||
/**
|
||||
* Returns true if this list contains no elements.
|
||||
*
|
||||
* @return true if this list contains no elements
|
||||
*/
|
||||
public boolean isEmpty();
|
||||
|
||||
/**
|
||||
* delayed passing through of parameter
|
||||
*
|
||||
* @param element element to pass through
|
||||
* @return passed though element
|
||||
*
|
||||
*/
|
||||
public default T delay(T element) {
|
||||
try {
|
||||
Thread.sleep(10);
|
||||
} catch (InterruptedException ex) {
|
||||
Thread.currentThread().interrupt();
|
||||
}
|
||||
return element;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,135 @@
|
|||
package pp;
|
||||
|
||||
import java.util.concurrent.locks.Lock;
|
||||
import java.util.concurrent.locks.ReentrantLock;
|
||||
|
||||
public class ThreadsafeSimplifiedList<T>
|
||||
implements SimplifiedList<T> {
|
||||
|
||||
private Node<T> head;
|
||||
private final Lock listLock = new ReentrantLock();
|
||||
|
||||
private class Node<U> {
|
||||
private U element;
|
||||
private Node<U> next;
|
||||
private final Lock nodeLock;
|
||||
|
||||
private Node(U element, Node<U> prev, Node<U> next) {
|
||||
super();
|
||||
this.element = element;
|
||||
this.next = next;
|
||||
this.nodeLock = new ReentrantLock();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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();
|
||||
if (this.head == null) {
|
||||
this.listLock.unlock();
|
||||
throw new IndexOutOfBoundsException("The list is empty");
|
||||
}
|
||||
|
||||
var ptr = this.head;
|
||||
ptr.nodeLock.lock();
|
||||
this.listLock.unlock();
|
||||
for (var i = 0; i < index; i++) {
|
||||
if (ptr.next != null) {
|
||||
ptr.next.nodeLock.lock();
|
||||
var savePtr = ptr;
|
||||
ptr = ptr.next;
|
||||
savePtr.nodeLock.unlock();
|
||||
} else {
|
||||
throw new IndexOutOfBoundsException(index + " out of bounds");
|
||||
}
|
||||
}
|
||||
|
||||
try {return delay(ptr.element);}
|
||||
finally { ptr.nodeLock.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.head != null) {
|
||||
var ptr = this.head;
|
||||
ptr.nodeLock.lock();
|
||||
this.listLock.unlock();
|
||||
while (ptr.next != null) {
|
||||
ptr.next.nodeLock.lock();
|
||||
var savePtr = ptr;
|
||||
ptr = ptr.next;
|
||||
savePtr.nodeLock.unlock();
|
||||
}
|
||||
ptr.next = new Node<>(element, ptr, null);
|
||||
ptr.nodeLock.unlock();
|
||||
} else {
|
||||
this.head = 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();
|
||||
if (this.head == null) {
|
||||
this.listLock.unlock();
|
||||
throw new IndexOutOfBoundsException("The list is empty");
|
||||
}
|
||||
var ptr = this.head;
|
||||
ptr.nodeLock.lock();
|
||||
this.listLock.unlock();
|
||||
for (var i = 0; i < index; i++) {
|
||||
if (ptr.next != null) {
|
||||
ptr.next.nodeLock.lock();
|
||||
var savePtr = ptr;
|
||||
ptr = ptr.next;
|
||||
savePtr.nodeLock.unlock();
|
||||
} else
|
||||
throw new IndexOutOfBoundsException(index + " out of bounds");
|
||||
|
||||
}
|
||||
try {
|
||||
ptr.element = element;
|
||||
return element;
|
||||
} finally {
|
||||
ptr.nodeLock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.head == null; }
|
||||
finally { this.listLock.unlock();}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue