final Version

Reviewed-on: #2

pp.A1-CondPhilosophers/src/main/java/pp/Philosopher.java

@@ -1,20 +1,86 @@
 package pp;
 
+import java.util.Random;
+import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 public class Philosopher extends Thread implements IPhilosopher {
 	private int seat;
+	private Philosopher rechts;
+	private Philosopher links;
+	private Lock table;
+	private Condition canEat;
+	private volatile boolean stopped;
+	private volatile boolean eating;
+	private final Random random;
+
+	public Philosopher() {
+		this.random = new Random();
+		this.seat = 0;
+		this.stopped = false;
+	}
+	
+
+	
+	@Override
+	public void run() {
+		try {
+			while (!this.stopped) {
+				think();
+				eat();
+			}
+		} catch (InterruptedException e) {
+		}
+	    log(seat,"beendet");
+	}
+
+	private void eat() throws InterruptedException {
+		this.table.lock();
+		try {
+
+			while (this.links.eating || this.rechts.eating) {
+				log(seat,"warten!");
+				this.canEat.await();
+			}
+			this.eating = true;
+			log(seat, " : isst gerade!");
+		} finally {
+			table.unlock();
+		}
+		Thread.sleep(this.random.nextInt(PhilosopherExperiment.MAX_EATING_DURATION_MS));
+	}
+
+	private void think() throws InterruptedException {
+		this.table.lock();
+	
+		try {
+			if (this.eating)
+				this.eating = false;
+			this.links.canEat.signal();
+			this.rechts.canEat.signal();
+			log(seat,"denken");
+			
+		} finally  {
+			this.table.unlock();
+		}
+		
+		Thread.sleep(random.nextInt(PhilosopherExperiment.MAX_THINKING_DURATION_MS));
+
+	}
 
 	@Override
 	public void setLeft(IPhilosopher left) {
 		// TODO Auto-generated method stub
 		// Cast auf Philosopher erforderlich
+		this.links = (Philosopher) left;
 	}
 
 	@Override
 	public void setRight(IPhilosopher right) {
 		// TODO Auto-generated method stub
 		// Cast auf Philosopher erforderlich
+		this.rechts = (Philosopher) right;
 	}
 
 	@Override
@@ -25,12 +91,48 @@ public class Philosopher extends Thread implements IPhilosopher {
 	@Override
 	public void setTable(Lock table) {
 		// TODO Auto-generated method stub
-
+		this.table = table;
+		canEat = this.table.newCondition();
+		
 	}
 
 	@Override
 	public void stopPhilosopher() {
-		// TODO Auto-generated method stub
-
+		this.stopped = true;
+		interrupt();
 	}
+	
+	public static void main(String[] args) throws InterruptedException {
+	    int numPhilosophers = 5;
+	    Lock table = new ReentrantLock();
+	    Philosopher[] philosophers = new Philosopher[numPhilosophers];
+	    
+	    for (int i = 0; i < numPhilosophers; i++) {
+	        philosophers[i] = new Philosopher();
+	        philosophers[i].setSeat(i);
+	        philosophers[i].setTable(table);
+	    }
+	    
+	    for (int i = 0; i < numPhilosophers; i++) {
+	        philosophers[i].setLeft(philosophers[(i + numPhilosophers - 1) % numPhilosophers]);
+	        philosophers[i].setRight(philosophers[(i + 1) % numPhilosophers]);
+	    }
+	    
+	    for (Philosopher p : philosophers) {
+	        p.start();
+	    }
+	    
+	    Thread.sleep(10_000);  // Laufzeit: 10 Sekunden
+	    
+	    for (Philosopher p : philosophers) {
+	        p.stopPhilosopher();
+	    }
+	    
+	    for (Philosopher p : philosophers) {
+	        p.join();
+	    }
+	    
+	    System.out.println("Experiment beendet!");
+	}
+
 }

pp.A4-HandOverHandLocking/.gitignore

@@ -0,0 +1,3 @@
+/target/
+/.classpath
+/.project

pp.A4-HandOverHandLocking/pom.xml

@@ -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>

pp.A4-HandOverHandLocking/src/main/java/pp/Main.java

@@ -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);
+    }
+
+}

pp.A4-HandOverHandLocking/src/main/java/pp/SimplifiedList.java

@@ -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;
+    }
+}

pp.A4-HandOverHandLocking/src/main/java/pp/ThreadsafeSimplifiedList.java

@@ -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();}
+    }
+}