initial

src/pp.07.01.synchronizedWrapper/justfile

@@ -0,0 +1,18 @@
+# Justfile (https://just.systems/) for starting Maven standard targets
+
+default: clean compile package
+
+exec class args: compile
+    mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}}
+# exec class args: 
+#     java -cp target/app.jar {{class}} {{args}}
+clean:
+    mvn clean
+compile:
+    mvn compile
+test: compile
+    mvn test
+javadoc:
+    mvn javadoc:javadoc
+package: 
+    mvn package

src/pp.07.01.synchronizedWrapper/pom.xml

@@ -0,0 +1,60 @@
+<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.07.01.synchronizedWrapper</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+
+  <properties>	
+    <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>
+    <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>

src/pp.07.01.synchronizedWrapper/src/main/java/pp/SynchWrapper.java

@@ -0,0 +1,16 @@
+package pp;
+
+import java.util.List;
+
+public class SynchWrapper<T> {
+    private final List<T> decorated;
+
+    public static <T> List<T> synchronizedList(List<T> list) {
+        return (List<T>) new SynchWrapper<>(list);
+    }
+
+    private SynchWrapper(List<T> list) {
+        this.decorated = list;
+    }
+
+}

src/pp.07.01.synchronizedWrapper_solution/justfile

@@ -0,0 +1,18 @@
+# Justfile (https://just.systems/) for starting Maven standard targets
+
+default: clean compile package
+
+exec class args: compile
+    mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}}
+# exec class args: 
+#     java -cp target/app.jar {{class}} {{args}}
+clean:
+    mvn clean
+compile:
+    mvn compile
+test: compile
+    mvn test
+javadoc:
+    mvn javadoc:javadoc
+package: 
+    mvn package

src/pp.07.01.synchronizedWrapper_solution/pom.xml

@@ -0,0 +1,59 @@
+<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.07.01.synchronizedWrapper_solution</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+
+  <properties>	
+    <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>edge-SNAPSHOT</version>
+    </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>
+    <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>

src/pp.07.01.synchronizedWrapper_solution/src/main/java/pp/SynchWrapper.java

@@ -0,0 +1,134 @@
+package pp;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public class SynchWrapper<T> implements List<T> {
+    private final List<T> decorated;
+
+    public static <T> List<T> synchronizedList(List<T> list) {
+        return new SynchWrapper<>(list);
+    }
+
+    private SynchWrapper(List<T> list) {
+        this.decorated = list;
+    }
+
+    @Override
+    public synchronized int size() {
+        return this.decorated.size();
+    }
+
+    @Override
+    public synchronized boolean isEmpty() {
+        return this.decorated.isEmpty();
+    }
+
+    @Override
+    public synchronized boolean contains(Object o) {
+        return this.decorated.contains(o);
+    }
+
+    @Override
+    public synchronized Iterator<T> iterator() {
+        return this.decorated.iterator();
+    }
+
+    @Override
+    public synchronized Object[] toArray() {
+        return this.decorated.toArray();
+    }
+
+    @Override
+    public synchronized <T> T[] toArray(T[] a) {
+        return this.decorated.toArray(a);
+    }
+
+    @Override
+    public synchronized boolean add(T e) {
+        return this.decorated.add(e);
+    }
+
+    @Override
+    public synchronized boolean remove(Object o) {
+        return this.decorated.remove(o);
+    }
+
+    @Override
+    public synchronized boolean containsAll(Collection<?> c) {
+        return this.decorated.containsAll(c);
+    }
+
+    @Override
+    public synchronized boolean addAll(Collection<? extends T> c) {
+        return this.decorated.addAll(c);
+    }
+
+    @Override
+    public synchronized boolean addAll(int index, Collection<? extends T> c) {
+        return this.decorated.addAll(index, c);
+    }
+
+    @Override
+    public synchronized boolean removeAll(Collection<?> c) {
+        return this.decorated.removeAll(c);
+    }
+
+    @Override
+    public synchronized boolean retainAll(Collection<?> c) {
+        return this.decorated.retainAll(c);
+    }
+
+    @Override
+    public synchronized void clear() {
+        this.decorated.clear();
+    }
+
+    @Override
+    public synchronized T get(int index) {
+        return this.decorated.get(index);
+    }
+
+    @Override
+    public synchronized T set(int index, T element) {
+        return this.decorated.set(index, element);
+    }
+
+    @Override
+    public synchronized void add(int index, T element) {
+        this.decorated.add(index, element);
+    }
+
+    @Override
+    public synchronized T remove(int index) {
+        return this.decorated.remove(index);
+    }
+
+    @Override
+    public synchronized int indexOf(Object o) {
+        return this.decorated.indexOf(o);
+    }
+
+    @Override
+    public synchronized int lastIndexOf(Object o) {
+        return this.decorated.lastIndexOf(o);
+    }
+
+    @Override
+    public synchronized ListIterator<T> listIterator() {
+        return this.decorated.listIterator();
+    }
+
+    @Override
+    public synchronized ListIterator<T> listIterator(int index) {
+        return this.decorated.listIterator(index);
+    }
+
+    @Override
+    public synchronized List<T> subList(int fromIndex, int toIndex) {
+        return this.decorated.subList(fromIndex, toIndex);
+    }
+
+}

src/pp.07.01.synchronizedWrapper_solution/src/main/java/pp/SynchWrapperLombok.java

@@ -0,0 +1,159 @@
+package pp;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+import lombok.Synchronized;
+
+public class SynchWrapperLombok<T> implements List<T> {
+  private final List<T> decorated;
+
+  public static <T> List<T> synchronizedList(List<T> list) {
+    return new SynchWrapperLombok<>(list);
+  }
+
+  private SynchWrapperLombok(List<T> list) {
+    this.decorated = list;
+  }
+
+  @Override
+  @Synchronized
+  public int size() {
+    return this.decorated.size();
+  }
+
+  @Override
+  @Synchronized
+  public boolean isEmpty() {
+    return this.decorated.isEmpty();
+  }
+
+  @Override
+  @Synchronized
+  public boolean contains(Object o) {
+    return this.decorated.contains(o);
+  }
+
+  @Override
+  @Synchronized
+  public Iterator<T> iterator() {
+    return this.decorated.iterator();
+  }
+
+  @Override
+  @Synchronized
+  public Object[] toArray() {
+    return this.decorated.toArray();
+  }
+
+  @Override
+  @Synchronized
+  public <T> T[] toArray(T[] a) {
+    return this.decorated.toArray(a);
+  }
+
+  @Override
+  @Synchronized
+  public boolean add(T e) {
+    return this.decorated.add(e);
+  }
+
+  @Override
+  @Synchronized
+  public boolean remove(Object o) {
+    return this.decorated.remove(o);
+  }
+
+  @Override
+  @Synchronized
+  public boolean containsAll(Collection<?> c) {
+    return this.decorated.containsAll(c);
+  }
+
+  @Override
+  @Synchronized
+  public boolean addAll(Collection<? extends T> c) {
+    return this.decorated.addAll(c);
+  }
+
+  @Override
+  @Synchronized
+  public boolean addAll(int index, Collection<? extends T> c) {
+    return this.decorated.addAll(index, c);
+  }
+
+  @Override
+  @Synchronized
+  public boolean removeAll(Collection<?> c) {
+    return this.decorated.removeAll(c);
+  }
+
+  @Override
+  @Synchronized
+  public boolean retainAll(Collection<?> c) {
+    return this.decorated.retainAll(c);
+  }
+
+  @Override
+  @Synchronized
+  public void clear() {
+    this.decorated.clear();
+  }
+
+  @Override
+  @Synchronized
+  public T get(int index) {
+    return this.decorated.get(index);
+  }
+
+  @Override
+  @Synchronized
+  public T set(int index, T element) {
+    return this.decorated.set(index, element);
+  }
+
+  @Override
+  @Synchronized
+  public void add(int index, T element) {
+    this.decorated.add(index, element);
+  }
+
+  @Override
+  @Synchronized
+  public T remove(int index) {
+    return this.decorated.remove(index);
+  }
+
+  @Override
+  @Synchronized
+  public int indexOf(Object o) {
+    return this.decorated.indexOf(o);
+  }
+
+  @Override
+  @Synchronized
+  public int lastIndexOf(Object o) {
+    return this.decorated.lastIndexOf(o);
+  }
+
+  @Override
+  @Synchronized
+  public ListIterator<T> listIterator() {
+    return this.decorated.listIterator();
+  }
+
+  @Override
+  @Synchronized
+  public ListIterator<T> listIterator(int index) {
+    return this.decorated.listIterator(index);
+  }
+
+  @Override
+  @Synchronized
+  public List<T> subList(int fromIndex, int toIndex) {
+    return this.decorated.subList(fromIndex, toIndex);
+  }
+
+}

src/pp.07.01.synchronizedWrapper_solution/src/main/java/pp/SynchWrapperRW.java

@@ -0,0 +1,258 @@
+package pp;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public class SynchWrapperRW<T> implements List<T> {
+    private final List<T> decorated;
+    private final ReadWriteLock lock;
+    private final Lock rLock;
+    private final Lock wLock;
+
+    public static <T> List<T> synchronizedList(List<T> list) {
+        return new SynchWrapperRW<>(list);
+    }
+
+    private SynchWrapperRW(List<T> list) {
+        this.decorated = list;
+        this.lock = new ReentrantReadWriteLock();
+        this.rLock = this.lock.readLock();
+        this.wLock = this.lock.writeLock();
+    }
+
+    @Override
+    public int size() {
+        this.rLock.lock();
+        try {
+            return this.decorated.size();
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean isEmpty() {
+        this.rLock.lock();
+        try {
+            return this.decorated.isEmpty();
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean contains(Object o) {
+        this.rLock.lock();
+        try {
+            return this.decorated.contains(o);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        this.rLock.lock();
+        try {
+            return this.decorated.iterator();
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public Object[] toArray() {
+        this.rLock.lock();
+        try {
+            return this.decorated.toArray();
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public <T> T[] toArray(T[] a) {
+        this.rLock.lock();
+        try {
+            return this.decorated.toArray(a);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean add(T e) {
+        this.wLock.lock();
+        try {
+            return this.decorated.add(e);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean remove(Object o) {
+        this.wLock.lock();
+        try {
+            return this.decorated.remove(o);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean containsAll(Collection<?> c) {
+        this.rLock.lock();
+        try {
+            return this.decorated.containsAll(c);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean addAll(Collection<? extends T> c) {
+        this.wLock.lock();
+        try {
+            return this.decorated.addAll(c);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean addAll(int index, Collection<? extends T> c) {
+        this.wLock.lock();
+        try {
+            return this.decorated.addAll(index, c);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean removeAll(Collection<?> c) {
+        this.wLock.lock();
+        try {
+            return this.decorated.removeAll(c);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean retainAll(Collection<?> c) {
+        this.wLock.lock();
+        try {
+            return this.decorated.retainAll(c);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public void clear() {
+        this.wLock.lock();
+        try {
+            this.decorated.clear();
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public T get(int index) {
+        this.rLock.lock();
+        try {
+            return this.decorated.get(index);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public T set(int index, T element) {
+        this.wLock.lock();
+        try {
+            return this.decorated.set(index, element);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public void add(int index, T element) {
+        this.wLock.lock();
+        try {
+            this.decorated.add(index, element);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public T remove(int index) {
+        this.wLock.lock();
+        try {
+            return this.decorated.remove(index);
+        } finally {
+            this.wLock.unlock();
+        }
+    }
+
+    @Override
+    public int indexOf(Object o) {
+        this.rLock.lock();
+        try {
+            return this.decorated.indexOf(o);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public int lastIndexOf(Object o) {
+        this.rLock.lock();
+        try {
+            return this.decorated.lastIndexOf(o);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public ListIterator<T> listIterator() {
+        this.rLock.lock();
+        try {
+            return this.decorated.listIterator();
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public ListIterator<T> listIterator(int index) {
+        this.rLock.lock();
+        try {
+            return this.decorated.listIterator(index);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+    @Override
+    public List<T> subList(int fromIndex, int toIndex) {
+        this.rLock.lock();
+        try {
+            return this.decorated.subList(fromIndex, toIndex);
+        } finally {
+            this.rLock.unlock();
+        }
+    }
+
+}

src/pp.07.01.synchronizedWrapper_solution/src/main/java/pp/SynchWrapperRWLombok.java

@@ -0,0 +1,162 @@
+package pp;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import lombok.Locked;
+
+public class SynchWrapperRWLombok<T> implements List<T> {
+    private final List<T> decorated;
+
+    public static <T> List<T> synchronizedList(List<T> list) {
+        return new SynchWrapperRWLombok<>(list);
+    }
+
+    private SynchWrapperRWLombok(List<T> list) {
+        this.decorated = list;
+    }
+
+    @Override
+    @Locked.Read
+    public int size() {
+        return this.decorated.size();
+    }
+
+    @Override
+    @Locked.Read
+    public boolean isEmpty() {
+        return this.decorated.isEmpty();
+    }
+
+    @Override
+    @Locked.Read
+    public boolean contains(Object o) {
+        return this.decorated.contains(o);
+    }
+
+    @Override
+    @Locked.Read
+    public Iterator<T> iterator() {
+        return this.decorated.iterator();
+    }
+
+    @Override
+    @Locked.Read
+    public Object[] toArray() {
+        return this.decorated.toArray();
+    }
+
+    @Override
+    @Locked.Read
+    public <T> T[] toArray(T[] a) {
+        return this.decorated.toArray(a);
+    }
+
+    @Override
+    @Locked.Write
+    public boolean add(T e) {
+        return this.decorated.add(e);
+    }
+
+    @Override
+    @Locked.Write
+    public boolean remove(Object o) {
+        return this.decorated.remove(o);
+    }
+
+    @Override
+    @Locked.Read
+    public boolean containsAll(Collection<?> c) {
+        return this.decorated.containsAll(c);
+    }
+
+    @Override
+    @Locked.Write
+    public boolean addAll(Collection<? extends T> c) {
+        return this.decorated.addAll(c);
+    }
+
+    @Override
+    @Locked.Write
+    public boolean addAll(int index, Collection<? extends T> c) {
+        return this.decorated.addAll(index, c);
+    }
+
+    @Override
+    @Locked.Write
+    public boolean removeAll(Collection<?> c) {
+        return this.decorated.removeAll(c);
+    }
+
+    @Override
+    @Locked.Write
+    public boolean retainAll(Collection<?> c) {
+        return this.decorated.retainAll(c);
+    }
+
+    @Override
+    @Locked.Write
+    public void clear() {
+        this.decorated.clear();
+    }
+
+    @Override
+    @Locked.Read
+    public T get(int index) {
+        return this.decorated.get(index);
+    }
+
+    @Override
+    @Locked.Write
+    public T set(int index, T element) {
+        return this.decorated.set(index, element);
+    }
+
+    @Override
+    @Locked.Write
+    public void add(int index, T element) {
+        this.decorated.add(index, element);
+    }
+
+    @Override
+    @Locked.Write
+    public T remove(int index) {
+        return this.decorated.remove(index);
+    }
+
+    @Override
+    @Locked.Read
+    public int indexOf(Object o) {
+        return this.decorated.indexOf(o);
+    }
+
+    @Override
+    @Locked.Read
+    public int lastIndexOf(Object o) {
+        return this.decorated.lastIndexOf(o);
+    }
+
+    @Override
+    @Locked.Read
+    public ListIterator<T> listIterator() {
+        return this.decorated.listIterator();
+    }
+
+    @Override
+    @Locked.Read
+    public ListIterator<T> listIterator(int index) {
+        return this.decorated.listIterator(index);
+    }
+
+    @Override
+    @Locked.Read
+    public List<T> subList(int fromIndex, int toIndex) {
+        return this.decorated.subList(fromIndex, toIndex);
+    }
+
+}

src/pp.07.01.synchronizedWrapper_solution/src/test/java/pp/Tests.java

@@ -0,0 +1,55 @@
+package pp;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class Tests {
+  private final static int SIZE = 10000;
+
+  static void testAdd(List<Integer> l) {
+    var t1 = new Thread(() -> {
+      for (var i = 0; i < SIZE; i++) {
+        l.add(Integer.valueOf(i));
+      }
+    });
+    var t2 = new Thread(() -> {
+      for (var i = 0; i < SIZE; i++) {
+        l.add(Integer.valueOf(i));
+      }
+    });
+    t1.start();
+    t2.start();
+    try {
+      t1.join();
+      t2.join();
+      assertEquals(l.size(), SIZE * 2);
+    } catch (InterruptedException e) {
+      fail("Interrupt");
+    }
+  }
+
+  @Test
+  void testWrappedListSynchronizedAdd() {
+    testAdd(SynchWrapper.synchronizedList(new ArrayList<Integer>()));
+  }
+
+  @Test
+  void testWrappedListReadWriteLockAdd() {
+    testAdd(SynchWrapperRW.synchronizedList(new ArrayList<Integer>()));
+  }
+
+  @Test
+  void testWrappedListLombokLockAdd() {
+    testAdd(SynchWrapperLombok.synchronizedList(new ArrayList<Integer>()));
+  }
+  
+  @Test
+  void testWrappedListReadWriteiLombokLockAdd() {
+    testAdd(SynchWrapperRWLombok.synchronizedList(new ArrayList<Integer>()));
+  }
+
+}

src/pp.07.02.Collections/justfile

@@ -0,0 +1,18 @@
+# Justfile (https://just.systems/) for starting Maven standard targets
+
+default: clean compile package
+
+exec class args: compile
+    mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}}
+# exec class args: 
+#     java -cp target/app.jar {{class}} {{args}}
+clean:
+    mvn clean
+compile:
+    mvn compile
+test: compile
+    mvn test
+javadoc:
+    mvn javadoc:javadoc
+package: 
+    mvn package

src/pp.07.02.Collections/pom.xml

@@ -0,0 +1,60 @@
+<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.07.02.Collections</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+
+  <properties>	
+    <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>
+    <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>

src/pp.07.02.Collections/src/main/java/pp/ExperimentVector.java

@@ -0,0 +1,48 @@
+package pp;
+
+import java.util.Vector;
+
+class ExperimentVector {
+    Integer countA;
+    Integer countB;
+    Vector<Integer> list;
+
+    void work(int size) throws InterruptedException {
+        this.countA = 0;
+        this.countB = 0;
+        this.list = new Vector<>();
+        var t1 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t2 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t3 = new Thread(() -> {
+            for (var i = 0; i < (size * 2); i++) {
+                this.countA += this.list.get(i);
+            }
+        });
+        var t4 = new Thread(() -> {
+            for (var i = (size * 2) - 1; i >= 0; i--) {
+                this.countB += this.list.get(i);
+            }
+        });
+        var now = System.currentTimeMillis();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        t3.start();
+        t4.start();
+        t3.join();
+        t4.join();
+        System.out.printf("Lauf %s, i=%d, Zeitdauer: %dms (%s)\n",
+                (this.countA.equals(this.countB)) ? "ok" : "fehlerhaft", size,
+                System.currentTimeMillis() - now, "Vector");
+    }
+
+}

src/pp.07.02.Collections_solution/justfile

@@ -0,0 +1,18 @@
+# Justfile (https://just.systems/) for starting Maven standard targets
+
+default: clean compile package
+
+exec class args: compile
+    mvn exec:java -Dexec.args="{{args}}" -Dexec.mainClass={{class}}
+# exec class args: 
+#     java -cp target/app.jar {{class}} {{args}}
+clean:
+    mvn clean
+compile:
+    mvn compile
+test: compile
+    mvn test
+javadoc:
+    mvn javadoc:javadoc
+package: 
+    mvn package

src/pp.07.02.Collections_solution/pom.xml

@@ -0,0 +1,60 @@
+<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.07.02.Collections_solution</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+
+  <properties>	
+    <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>
+    <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>

src/pp.07.02.Collections_solution/src/main/java/pp/ExperimentArrayList.java

@@ -0,0 +1,57 @@
+package pp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class ExperimentArrayList {
+    Integer countA;
+    Integer countB;
+    List<Integer> list;
+
+    void work(int size) throws InterruptedException {
+        this.countA = 0;
+        this.countB = 0;
+        this.list = new ArrayList<>();
+        var t1 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                synchronized (this.list) {
+                    this.list.add(1);
+                }
+            }
+        });
+        var t2 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                synchronized (this.list) {
+                    this.list.add(1);
+                }
+            }
+        });
+        var t3 = new Thread(() -> {
+            for (var i = 0; i < (size * 2); i++) {
+                synchronized (this.list) {
+                    this.countA += this.list.get(i);
+                }
+            }
+        });
+        var t4 = new Thread(() -> {
+            for (var i = (size * 2) - 1; i >= 0; i--) {
+                synchronized (this.list) {
+                    this.countB += this.list.get(i);
+                }
+            }
+        });
+        var now = System.currentTimeMillis();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        t3.start();
+        t4.start();
+        t3.join();
+        t4.join();
+        System.out.printf("Lauf %s, i=%d, Zeitdauer: %dms (%s)\n",
+                (this.countA.equals(this.countB)) ? "ok" : "fehlerhaft", size,
+                System.currentTimeMillis() - now, "ArrayList");
+    }
+
+}

src/pp.07.02.Collections_solution/src/main/java/pp/ExperimentLinkedList.java

@@ -0,0 +1,57 @@
+package pp;
+
+import java.util.LinkedList;
+import java.util.List;
+
+class ExperimentLinkedList {
+    Integer countA;
+    Integer countB;
+    List<Integer> list;
+
+    void work(int size) throws InterruptedException {
+        this.countA = 0;
+        this.countB = 0;
+        this.list = new LinkedList<>();
+        var t1 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                synchronized (this.list) {
+                    this.list.add(1);
+                }
+            }
+        });
+        var t2 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                synchronized (this.list) {
+                    this.list.add(1);
+                }
+            }
+        });
+        var t3 = new Thread(() -> {
+            for (var i = 0; i < (size * 2); i++) {
+                synchronized (this.list) {
+                    this.countA += this.list.get(i);
+                }
+            }
+        });
+        var t4 = new Thread(() -> {
+            for (var i = (size * 2) - 1; i >= 0; i--) {
+                synchronized (this.list) {
+                    this.countB += this.list.get(i);
+                }
+            }
+        });
+        var now = System.currentTimeMillis();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        t3.start();
+        t4.start();
+        t3.join();
+        t4.join();
+        System.out.printf("Lauf %s, i=%d, Zeitdauer: %dms (%s)\n",
+                (this.countA.equals(this.countB)) ? "ok" : "fehlerhaft", size,
+                System.currentTimeMillis() - now, "LinkedList");
+    }
+
+}

src/pp.07.02.Collections_solution/src/main/java/pp/ExperimentSynchedArrayList.java

@@ -0,0 +1,50 @@
+package pp;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class ExperimentSynchedArrayList {
+    Integer countA;
+    Integer countB;
+    List<Integer> list;
+
+    void work(int size) throws InterruptedException {
+        this.countA = 0;
+        this.countB = 0;
+        this.list = Collections.synchronizedList(new ArrayList<>());
+        var t1 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t2 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t3 = new Thread(() -> {
+            for (var i = 0; i < (size * 2); i++) {
+                this.countA += this.list.get(i);
+            }
+        });
+        var t4 = new Thread(() -> {
+            for (var i = (size * 2) - 1; i >= 0; i--) {
+                this.countB += this.list.get(i);
+            }
+        });
+        var now = System.currentTimeMillis();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        t3.start();
+        t4.start();
+        t3.join();
+        t4.join();
+        System.out.printf("Lauf %s, i=%d, Zeitdauer: %dms (%s)\n",
+                (this.countA.equals(this.countB)) ? "ok" : "fehlerhaft", size,
+                System.currentTimeMillis() - now, "SynchedArrayList");
+    }
+
+}

src/pp.07.02.Collections_solution/src/main/java/pp/ExperimentSynchedLinkedList.java

@@ -0,0 +1,50 @@
+package pp;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+class ExperimentSynchedLinkedList {
+    Integer countA;
+    Integer countB;
+    List<Integer> list;
+
+    void work(int size) throws InterruptedException {
+        this.countA = 0;
+        this.countB = 0;
+        this.list = Collections.synchronizedList(new LinkedList<>());
+        var t1 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t2 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t3 = new Thread(() -> {
+            for (var i = 0; i < (size * 2); i++) {
+                this.countA += this.list.get(i);
+            }
+        });
+        var t4 = new Thread(() -> {
+            for (var i = (size * 2) - 1; i >= 0; i--) {
+                this.countB += this.list.get(i);
+            }
+        });
+        var now = System.currentTimeMillis();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        t3.start();
+        t4.start();
+        t3.join();
+        t4.join();
+        System.out.printf("Lauf %s, i=%d, Zeitdauer: %dms (%s)\n",
+                (this.countA.equals(this.countB)) ? "ok" : "fehlerhaft", size,
+                System.currentTimeMillis() - now, "SynchedLinkedList");
+    }
+
+}

src/pp.07.02.Collections_solution/src/main/java/pp/ExperimentSynchedLinkedListRO.java

@@ -0,0 +1,55 @@
+package pp;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+class ExperimentSynchedLinkedListRO {
+    Integer countA;
+    Integer countB;
+    List<Integer> list;
+    List<Integer> listSynch;
+    List<Integer> listRO;
+
+    void work(int size) throws InterruptedException {
+        this.countA = 0;
+        this.countB = 0;
+        this.list = new LinkedList<>();
+        this.listSynch = Collections.synchronizedList(this.list);
+        this.listRO = Collections.unmodifiableList(this.list);
+
+        var t1 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.listSynch.add(1);
+            }
+        });
+        var t2 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.listSynch.add(1);
+            }
+        });
+        var t3 = new Thread(() -> {
+            for (var i = 0; i < (size * 2); i++) {
+                this.countA += this.listRO.get(i);
+            }
+        });
+        var t4 = new Thread(() -> {
+            for (var i = (size * 2) - 1; i >= 0; i--) {
+                this.countB += this.listRO.get(i);
+            }
+        });
+        var now = System.currentTimeMillis();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        t3.start();
+        t4.start();
+        t3.join();
+        t4.join();
+        System.out.printf("Lauf %s, i=%d, Zeitdauer: %dms (%s)\n",
+                (this.countA.equals(this.countB)) ? "ok" : "fehlerhaft", size,
+                System.currentTimeMillis() - now, "SynchedLinkedListRO");
+    }
+
+}

src/pp.07.02.Collections_solution/src/main/java/pp/ExperimentVector.java

@@ -0,0 +1,48 @@
+package pp;
+
+import java.util.Vector;
+
+class ExperimentVector {
+    Integer countA;
+    Integer countB;
+    Vector<Integer> list;
+
+    void work(int size) throws InterruptedException {
+        this.countA = 0;
+        this.countB = 0;
+        this.list = new Vector<>();
+        var t1 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t2 = new Thread(() -> {
+            for (var i = 0; i < size; i++) {
+                this.list.add(1);
+            }
+        });
+        var t3 = new Thread(() -> {
+            for (var i = 0; i < (size * 2); i++) {
+                this.countA += this.list.get(i);
+            }
+        });
+        var t4 = new Thread(() -> {
+            for (var i = (size * 2) - 1; i >= 0; i--) {
+                this.countB += this.list.get(i);
+            }
+        });
+        var now = System.currentTimeMillis();
+        t1.start();
+        t2.start();
+        t1.join();
+        t2.join();
+        t3.start();
+        t4.start();
+        t3.join();
+        t4.join();
+        System.out.printf("Lauf %s, i=%d, Zeitdauer: %dms (%s)\n",
+                (this.countA.equals(this.countB)) ? "ok" : "fehlerhaft", size,
+                System.currentTimeMillis() - now, "Vector");
+    }
+
+}

src/pp.07.02.Collections_solution/src/main/java/pp/Main.java

@@ -0,0 +1,15 @@
+package pp;
+
+public class Main {
+
+    public static void main(String... args) throws InterruptedException {
+        for (var i = 100; i <= 100000; i *= 10) {
+            (new ExperimentVector()).work(i);
+            (new ExperimentArrayList()).work(i);
+            (new ExperimentLinkedList()).work(i);
+            (new ExperimentSynchedArrayList()).work(i);
+            (new ExperimentSynchedLinkedList()).work(i);
+            (new ExperimentSynchedLinkedListRO()).work(i);
+        }
+    }
+}