adds exercise week 3

Author: Kevin Kirn

week3/exercise/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="lib" path="lib/jcip-annotations.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

week3/exercise/.gitignore

@@ -0,0 +1 @@
+/bin/

week3/exercise/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>03_LE_Condition_Synchronization</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

week3/exercise/LE_Condition_Synchronization.pdf

@@ -0,0 +1,33 @@
+package carpark;
+
+public class Car extends Thread {
+	private final CarPark carpark;
+
+	public Car(String name, CarPark carpark) {
+		super(name);
+		this.carpark = carpark;
+	}
+
+	public void run() {
+		while (true) {
+			spendSomeTime(10);
+			log("try to enter carpark");
+			carpark.enter(); // wait until place is available
+			spendSomeTime(20);
+			log("try to exit carpark");
+			carpark.exit();
+		}
+	}
+
+	private void spendSomeTime(int max) {
+		try {
+			sleep((int) (Math.random() * max * 1000));
+		} catch (InterruptedException e) {
+		}
+	}
+
+	private void log(String msg) {
+		System.out.println(Thread.currentThread().getName() + " " + msg);
+	}
+
+}

week3/exercise/WS_Semaphore.pdf

@@ -0,0 +1,6 @@
+package carpark;
+
+public interface CarPark {
+	void enter();
+	void exit();
+}

week3/exercise/src/carpark/Car.java

@@ -0,0 +1,35 @@
+package carpark;
+
+public class CarPark1 implements CarPark {
+	private int places;
+	
+	public CarPark1(int places) {
+		this.places = places;
+	}
+
+	@Override
+	public synchronized void enter() {
+		while(places == 0) { } // busy waiting
+		log("enter carpark");
+		places --;
+	}
+
+	@Override
+	public synchronized void exit() {
+		log("exit carpark");
+		places++;
+	}
+
+	public static void main(String[] args) {
+		CarPark cp = new CarPark1(2);
+		Car c1 = new Car("car1", cp); c1.start();
+		Car c2 = new Car("car2", cp); c2.start();
+		Car c3 = new Car("car3", cp); c3.start();
+		Car c4 = new Car("car4", cp); c4.start();
+	}
+	
+	private void log(String msg) {
+		System.out.println(Thread.currentThread().getName() + " " + msg);
+	}
+	
+}

week3/exercise/src/carpark/CarPark.java

@@ -0,0 +1,48 @@
+package carpark;
+
+
+public class CarPark2 implements CarPark {
+	private int places;
+
+	public CarPark2(int places) {
+		this.places = places;
+	}
+
+	private synchronized boolean isFull() {
+		return places == 0;
+	}
+
+	private synchronized void decPlaces() {
+		places--;
+		System.out.println("places: " + places);
+	}
+
+	private synchronized void incPlaces() {
+		places++;
+	}
+
+	@Override
+	public void enter() {
+		while(isFull()) { } // busy waiting
+		log("enter carpark");
+		decPlaces();
+	}
+
+	@Override
+	public void exit() {
+		log("exit carpark");
+		incPlaces();
+	}
+
+	public static void main(String[] args) {
+		CarPark cp = new CarPark2(2);
+		Car c1 = new Car("car1", cp); c1.start();
+		Car c2 = new Car("car2", cp); c2.start();
+		Car c3 = new Car("car3", cp); c3.start();
+		Car c4 = new Car("car4", cp); c4.start();
+	}
+	
+	private void log(String msg){
+		System.out.println(Thread.currentThread().getName() + " " + msg);
+	}
+}

week3/exercise/src/carpark/CarPark1.java

@@ -0,0 +1,56 @@
+package carpark;
+
+import net.jcip.annotations.GuardedBy;
+
+public class CarPark3 implements CarPark {
+	@GuardedBy("this")
+	private int places;
+	
+	public CarPark3(int places){
+		this.places = places;
+	}
+	
+	private boolean isFull(){
+		return places == 0;
+	}
+
+	@Override
+	public void enter() {
+		while (true) {
+			synchronized (this) {
+				if (!isFull()) {
+					log("enter carpark");
+					places--;
+					return;
+				}
+			}
+			sleep(10);
+		}
+	}
+
+	@Override
+	public synchronized void exit() {
+		log("exit carpark");
+		places++;
+	}
+
+	private void sleep(int time) {
+		try {
+			Thread.sleep(time);
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void main(String[] args){
+		CarPark cp = new CarPark3(2);
+		Car c1 = new Car("car1", cp); c1.start();
+		Car c2 = new Car("car2", cp); c2.start();
+		Car c3 = new Car("car3", cp); c3.start();
+		Car c4 = new Car("car4", cp); c4.start();
+	}
+	
+	private void log(String msg){
+		System.out.println(Thread.currentThread().getName() + " " + msg);
+	}
+}

week3/exercise/src/carpark/CarPark2.java

@@ -0,0 +1,40 @@
+package carpark;
+
+public class CarPark4 implements CarPark {
+	private int places;
+	
+	public CarPark4(int places){
+		this.places = places;
+	}
+	
+	@Override
+	public synchronized void enter() {
+		while(places == 0) {
+			try {
+				wait();
+			} catch (InterruptedException e) {
+			}
+		}
+		log("enter carpark");
+		places--;
+	}
+
+	@Override
+	public synchronized void exit() {
+		log("exit carpark");
+		places++;
+		notify();
+	}
+
+	public static void main(String[] args){
+		CarPark cp = new CarPark4(2);
+		Car c1 = new Car("car1", cp); c1.start();
+		Car c2 = new Car("car2", cp); c2.start();
+		Car c3 = new Car("car3", cp); c3.start();
+		Car c4 = new Car("car4", cp); c4.start();
+	}
+	
+	private void log(String msg){
+		System.out.println(Thread.currentThread().getName() + " " + msg);
+	}
+}

week3/exercise/src/carpark/CarPark3.java

@@ -0,0 +1,30 @@
+package carpark;
+
+public class CarPark5 implements CarPark {
+	private int places;
+
+	public CarPark5(int places) {
+		this.places = places;
+	}
+
+	private Object lock = new Object();
+
+	public void enter() {
+		synchronized (lock) {
+			while (places == 0) {
+				try {
+					lock.wait();
+				} catch (InterruptedException e) {
+				}
+			}
+			places--;
+		}
+	}
+
+	public void exit() {
+		synchronized (lock) {
+			places++;
+			lock.notify();
+		}
+	}
+}

week3/exercise/src/carpark/CarPark4.java

@@ -0,0 +1,25 @@
+package interrupt;
+
+public class Test1 {
+
+	public static void main(String[] args) {
+		Thread.currentThread().interrupt();
+		System.out.println(Thread.interrupted());
+		try {
+			Thread.sleep(1000);
+			System.out.println("ok1");
+		} catch (InterruptedException e) {
+			System.out.println("IE: " + Thread.currentThread().isInterrupted());
+		}
+		
+		Thread.currentThread().interrupt();
+		System.out.println(Thread.currentThread().isInterrupted());
+		try {
+			Thread.sleep(1000);
+			System.out.println("ok2");
+		} catch (InterruptedException e) {
+			System.out.println("IE: " + Thread.currentThread().isInterrupted());
+		}
+	}
+
+}

week3/exercise/src/carpark/CarPark5.java

@@ -0,0 +1,49 @@
+package interrupt;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+public class UnlockTest {
+
+   public static void main(String[] args) throws InterruptedException {
+
+      Thread good = new Thread() {
+         public void run() {
+            try {
+               interrupt();
+               ReentrantLock lock = new ReentrantLock();
+
+               lock.lockInterruptibly();
+               try {
+                  // do locked
+               } finally {
+                  lock.unlock();
+               }
+            } catch (InterruptedException ex) {
+               System.out.println("InterruptedException");
+            }
+
+         }
+      };
+
+      good.start();
+      good.join();
+
+      System.out.println("Checkpoint!");
+
+      Thread bad = new Thread() {
+         public void run() { 
+            ReentrantLock lock = new ReentrantLock();
+            interrupt();
+            try {
+               lock.lockInterruptibly();
+               // do locked
+            } catch (InterruptedException ex) {
+               System.out.println("InterruptedException");
+            } finally {
+               lock.unlock();
+            }
+         }
+      };
+      bad.start();
+   }
+}

week3/exercise/src/interrupt/Test1.java

@@ -0,0 +1,38 @@
+package worksheet;
+
+public final class Semaphore {
+
+	private int value;
+	private final Object LOCK = new Object();
+
+	public Semaphore(int initial) {
+		if (initial < 0)
+			throw new IllegalArgumentException();
+		value = initial;
+	}
+
+	public int available() {
+		return value;
+	}
+
+	public void acquire() {
+		synchronized (LOCK) {
+			while (value == 0) {
+				try {
+					LOCK.wait();
+				} catch (InterruptedException e) {
+					// NOP
+				}
+			}
+
+			value--; // decrement value
+		}
+	}
+
+	public void release() {
+		synchronized (LOCK) {
+			value++; // increment value
+			LOCK.notify(); // notify a waiting thread
+		}
+	}
+}