#354 Add maven model for feature toggle design pattern

reader-writer-lock/src/main/java/com/iluwatar/reader/writer/lock/App.java

@@ -0,0 +1,56 @@
+package com.iluwatar.reader.writer.lock;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+
+/**
+ * 
+ * In a multiple thread applications, the threads may try to synchronize the shared resources
+ * regardless of read or write operation. It leads to a low performance especially in a "read more
+ * write less" system as indeed the read operations are thread-safe to another read operation.
+ * <p>
+ * Reader writer lock is a synchronization primitive that try to resolve this problem. This pattern
+ * allows concurrent access for read-only operations, while write operations require exclusive
+ * access. This means that multiple threads can read the data in parallel but an exclusive lock is
+ * needed for writing or modifying data. When a writer is writing the data, all other writers or
+ * readers will be blocked until the writer is finished writing.
+ * 
+ * <p>
+ * This example use two mutex to demonstrate the concurrent access of multiple readers and writers.
+ * 
+ * 
+ * @author hongshuwei@gmail.com
+ */
+public class App {
+
+  /**
+   * Program entry point
+   * 
+   * @param args command line args
+   */
+  public static void main(String[] args) {
+
+    ExecutorService executeService = Executors.newFixedThreadPool(10);
+    ReaderWriterLock lock = new ReaderWriterLock();
+
+    // Start 5 readers
+    IntStream.range(0, 5)
+        .forEach(i -> executeService.submit(new Reader("Reader " + i, lock.readLock())));
+
+    // Start 5 writers
+    IntStream.range(0, 5)
+        .forEach(i -> executeService.submit(new Writer("Writer " + i, lock.writeLock())));
+    // In the system console, it can see that the read operations are executed concurrently while
+    // write operations are exclusive.
+    executeService.shutdown();
+    try {
+      executeService.awaitTermination(5, TimeUnit.SECONDS);
+    } catch (InterruptedException e) {
+      System.out.println("Error waiting for ExecutorService shutdown");
+    }
+
+  }
+
+}

reader-writer-lock/src/main/java/com/iluwatar/reader/writer/lock/Reader.java

@@ -0,0 +1,40 @@
+package com.iluwatar.reader.writer.lock;
+
+import java.util.concurrent.locks.Lock;
+
+/**
+ * Reader class, read when it acquired the read lock
+ */
+public class Reader implements Runnable {
+
+  private Lock readLock;
+
+  private String name;
+
+  public Reader(String name, Lock readLock) {
+    this.name = name;
+    this.readLock = readLock;
+  }
+
+  @Override
+  public void run() {
+    readLock.lock();
+    try {
+      read();
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    } finally {
+      readLock.unlock();
+    }
+  }
+
+  /**
+   * Simulate the read operation
+   * 
+   */
+  public void read() throws InterruptedException {
+    System.out.println(name + " begin");
+    Thread.sleep(250);
+    System.out.println(name + " finish");
+  }
+}

reader-writer-lock/src/main/java/com/iluwatar/reader/writer/lock/ReaderWriterLock.java

@@ -0,0 +1,211 @@
+package com.iluwatar.reader.writer.lock;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+
+/**
+ * Class responsible for control the access for reader or writer
+ * 
+ * Allows multiple readers to hold the lock at same time, but if any writer holds the lock then
+ * readers wait. If reader holds the lock then writer waits. This lock is not fair.
+ */
+public class ReaderWriterLock implements ReadWriteLock {
+
+
+  private Object readerMutex = new Object();
+
+  private int currentReaderCount = 0;
+
+  /**
+   * Global mutex is used to indicate that whether reader or writer gets the lock in the moment.
+   * <p>
+   * 1. When it contains the reference of {@link readerLock}, it means that the lock is acquired by
+   * the reader, another reader can also do the read operation concurrently. <br>
+   * 2. When it contains the reference of reference of {@link writerLock}, it means that the lock is
+   * acquired by the writer exclusively, no more reader or writer can get the lock.
+   * <p>
+   * This is the most important field in this class to control the access for reader/writer.
+   */
+  private Set<Object> globalMutex = new HashSet<>();
+
+  private ReadLock readerLock = new ReadLock();
+  private WriteLock writerLock = new WriteLock();
+
+  @Override
+  public Lock readLock() {
+    return readerLock;
+  }
+
+  @Override
+  public Lock writeLock() {
+    return writerLock;
+  }
+
+  /**
+   * return true when globalMutex hold the reference of writerLock
+   */
+  private boolean doesWriterOwnThisLock() {
+    return globalMutex.contains(writerLock);
+  }
+
+  /**
+   * return true when globalMutex hold the reference of readerLock
+   */
+  private boolean doesReaderOwnThisLock() {
+    return globalMutex.contains(readerLock);
+  }
+
+  /**
+   * Nobody get the lock when globalMutex contains nothing
+   * 
+   */
+  private boolean isLockFree() {
+    return globalMutex.isEmpty();
+  }
+
+  private void waitUninterruptibly(Object o) {
+    try {
+      o.wait();
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   * Reader Lock, can be access for more than one reader concurrently if no writer get the lock
+   */
+  private class ReadLock implements Lock {
+
+    @Override
+    public void lock() {
+
+      synchronized (readerMutex) {
+
+        currentReaderCount++;
+        if (currentReaderCount == 1) {
+          // Try to get the globalMutex lock for the first reader
+          synchronized (globalMutex) {
+            while (true) {
+              // If the no one get the lock or the lock is locked by reader, just set the reference
+              // to the globalMutex to indicate that the lock is locked by Reader.
+              if (isLockFree() || doesReaderOwnThisLock()) {
+                globalMutex.add(this);
+                break;
+              } else {
+                // If lock is acquired by the write, let the thread wait until the writer release
+                // the lock
+                waitUninterruptibly(globalMutex);
+              }
+            }
+          }
+
+        }
+      }
+    }
+
+    @Override
+    public void unlock() {
+
+      synchronized (readerMutex) {
+        currentReaderCount--;
+        // Release the lock only when it is the last reader, it is ensure that the lock is released
+        // when all reader is completely.
+        if (currentReaderCount == 0) {
+          synchronized (globalMutex) {
+            // Notify the waiter, mostly the writer
+            globalMutex.remove(this);
+            globalMutex.notifyAll();
+          }
+        }
+      }
+
+    }
+
+    @Override
+    public void lockInterruptibly() throws InterruptedException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean tryLock() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Condition newCondition() {
+      throw new UnsupportedOperationException();
+    }
+
+  }
+
+  /**
+   * Writer Lock, can only be accessed by one writer concurrently
+   */
+  private class WriteLock implements Lock {
+
+    @Override
+    public void lock() {
+
+      synchronized (globalMutex) {
+
+        while (true) {
+          // When there is no one acquired the lock, just put the writeLock reference to the
+          // globalMutex to indicate that the lock is acquired by one writer.
+          // It is ensure that writer can only get the lock when no reader/writer acquired the lock.
+          if (isLockFree()) {
+            globalMutex.add(this);
+            break;
+          } else if (doesWriterOwnThisLock()) {
+            // Wait when other writer get the lock
+            waitUninterruptibly(globalMutex);
+          } else if (doesReaderOwnThisLock()) {
+            // Wait when other reader get the lock
+            waitUninterruptibly(globalMutex);
+          } else {
+            throw new AssertionError("it should never reach here");
+          }
+        }
+      }
+    }
+
+    @Override
+    public void unlock() {
+
+      synchronized (globalMutex) {
+        globalMutex.remove(this);
+        // Notify the waiter, other writer or reader
+        globalMutex.notifyAll();
+      }
+    }
+
+    @Override
+    public void lockInterruptibly() throws InterruptedException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean tryLock() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Condition newCondition() {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+}

reader-writer-lock/src/main/java/com/iluwatar/reader/writer/lock/Writer.java

@@ -0,0 +1,40 @@
+package com.iluwatar.reader.writer.lock;
+
+import java.util.concurrent.locks.Lock;
+
+/**
+ * Writer class, write when it acquired the write lock
+ */
+public class Writer implements Runnable {
+
+  private Lock writeLock = null;
+
+  private String name;
+
+  public Writer(String name, Lock writeLock) {
+    this.name = name;
+    this.writeLock = writeLock;
+  }
+
+
+  @Override
+  public void run() {
+    writeLock.lock();
+    try {
+      write();
+    } catch (InterruptedException e) {
+      e.printStackTrace();
+    } finally {
+      writeLock.unlock();
+    }
+  }
+
+  /**
+   * Simulate the write operation
+   */
+  public void write() throws InterruptedException {
+    System.out.println(name + " begin");
+    Thread.sleep(250);
+    System.out.println(name + " finish");
+  }
+}

reader-writer-lock/src/test/java/com/iluwatar/reader/writer/lock/AppTest.java

@@ -0,0 +1,16 @@
+package com.iluwatar.reader.writer.lock;
+
+import org.junit.Test;
+
+/**
+ * Application test
+ */
+public class AppTest {
+
+  @Test
+  public void test() throws Exception {
+    String[] args = {};
+    App.main(args);
+
+  }
+}

reader-writer-lock/src/test/java/com/iluwatar/reader/writer/lock/ReaderAndWriterTest.java

@@ -0,0 +1,81 @@
+package com.iluwatar.reader.writer.lock;
+
+import static org.mockito.Mockito.inOrder;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+/**
+ * @author hongshuwei@gmail.com
+ */
+public class ReaderAndWriterTest extends StdOutTest {
+
+
+
+  /**
+   * Verify reader and writer can only get the lock to read and write orderly
+   */
+  @Test
+  public void testReadAndWrite() throws Exception {
+
+    ReaderWriterLock lock = new ReaderWriterLock();
+
+    Reader reader1 = new Reader("Reader 1", lock.readLock());
+    Writer writer1 = new Writer("Writer 1", lock.writeLock());
+
+    ExecutorService executeService = Executors.newFixedThreadPool(2);
+    executeService.submit(reader1);
+    // Let reader1 execute first
+    Thread.sleep(150);
+    executeService.submit(writer1);
+
+    executeService.shutdown();
+    try {
+      executeService.awaitTermination(10, TimeUnit.SECONDS);
+    } catch (InterruptedException e) {
+      System.out.println("Error waiting for ExecutorService shutdown");
+    }
+
+    final InOrder inOrder = inOrder(getStdOutMock());
+    inOrder.verify(getStdOutMock()).println("Reader 1 begin");
+    inOrder.verify(getStdOutMock()).println("Reader 1 finish");
+    inOrder.verify(getStdOutMock()).println("Writer 1 begin");
+    inOrder.verify(getStdOutMock()).println("Writer 1 finish");
+  }
+
+  /**
+   * Verify reader and writer can only get the lock to read and write orderly
+   */
+  @Test
+  public void testWriteAndRead() throws Exception {
+
+    ExecutorService executeService = Executors.newFixedThreadPool(2);
+    ReaderWriterLock lock = new ReaderWriterLock();
+
+    Reader reader1 = new Reader("Reader 1", lock.readLock());
+    Writer writer1 = new Writer("Writer 1", lock.writeLock());
+
+    executeService.submit(writer1);
+    // Let writer1 execute first
+    Thread.sleep(150);
+    executeService.submit(reader1);
+
+    executeService.shutdown();
+    try {
+      executeService.awaitTermination(10, TimeUnit.SECONDS);
+    } catch (InterruptedException e) {
+      System.out.println("Error waiting for ExecutorService shutdown");
+    }
+
+    final InOrder inOrder = inOrder(getStdOutMock());
+    inOrder.verify(getStdOutMock()).println("Writer 1 begin");
+    inOrder.verify(getStdOutMock()).println("Writer 1 finish");
+    inOrder.verify(getStdOutMock()).println("Reader 1 begin");
+    inOrder.verify(getStdOutMock()).println("Reader 1 finish");
+  }
+}
+

reader-writer-lock/src/test/java/com/iluwatar/reader/writer/lock/ReaderTest.java

@@ -0,0 +1,50 @@
+package com.iluwatar.reader.writer.lock;
+
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.spy;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+/**
+ * @author hongshuwei@gmail.com
+ */
+public class ReaderTest extends StdOutTest {
+
+  /**
+   * Verify that multiple readers can get the read lock concurrently
+   */
+  @Test
+  public void testRead() throws Exception {
+
+    ExecutorService executeService = Executors.newFixedThreadPool(2);
+    ReaderWriterLock lock = new ReaderWriterLock();
+
+    Reader reader1 = spy(new Reader("Reader 1", lock.readLock()));
+    Reader reader2 = spy(new Reader("Reader 2", lock.readLock()));
+
+    executeService.submit(reader1);
+    Thread.sleep(150);
+    executeService.submit(reader2);
+
+    executeService.shutdown();
+    try {
+      executeService.awaitTermination(10, TimeUnit.SECONDS);
+    } catch (InterruptedException e) {
+      System.out.println("Error waiting for ExecutorService shutdown");
+    }
+
+    // Read operation will hold the read lock 250 milliseconds, so here we prove that multiple reads
+    // can be performed in the same time.
+    final InOrder inOrder = inOrder(getStdOutMock());
+    inOrder.verify(getStdOutMock()).println("Reader 1 begin");
+    inOrder.verify(getStdOutMock()).println("Reader 2 begin");
+    inOrder.verify(getStdOutMock()).println("Reader 1 finish");
+    inOrder.verify(getStdOutMock()).println("Reader 2 finish");
+
+  }
+}

reader-writer-lock/src/test/java/com/iluwatar/reader/writer/lock/StdOutTest.java

@@ -0,0 +1,53 @@
+package com.iluwatar.reader.writer.lock;
+
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.PrintStream;
+
+import static org.mockito.Mockito.mock;
+
+/**
+ * Date: 12/10/15 - 8:37 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public abstract class StdOutTest {
+
+  /**
+   * The mocked standard out {@link PrintStream}, required since some actions don't have any
+   * influence on accessible objects, except for writing to std-out using {@link System#out}
+   */
+  private final PrintStream stdOutMock = mock(PrintStream.class);
+
+  /**
+   * Keep the original std-out so it can be restored after the test
+   */
+  private final PrintStream stdOutOrig = System.out;
+
+  /**
+   * Inject the mocked std-out {@link PrintStream} into the {@link System} class before each test
+   */
+  @Before
+  public void setUp() {
+    System.setOut(this.stdOutMock);
+  }
+
+  /**
+   * Removed the mocked std-out {@link PrintStream} again from the {@link System} class
+   */
+  @After
+  public void tearDown() {
+    System.setOut(this.stdOutOrig);
+  }
+
+  /**
+   * Get the mocked stdOut {@link PrintStream}
+   *
+   * @return The stdOut print stream mock, renewed before each test
+   */
+  final PrintStream getStdOutMock() {
+    return this.stdOutMock;
+  }
+
+}

reader-writer-lock/src/test/java/com/iluwatar/reader/writer/lock/WriterTest.java

@@ -0,0 +1,50 @@
+package com.iluwatar.reader.writer.lock;
+
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.spy;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Test;
+import org.mockito.InOrder;
+
+/**
+ * @author hongshuwei@gmail.com
+ */
+public class WriterTest extends StdOutTest {
+
+  /**
+   * Verify that multiple writers will get the lock in order.
+   */
+  @Test
+  public void testWrite() throws Exception {
+
+    ExecutorService executeService = Executors.newFixedThreadPool(2);
+    ReaderWriterLock lock = new ReaderWriterLock();
+
+    Writer writer1 = spy(new Writer("Writer 1", lock.writeLock()));
+    Writer writer2 = spy(new Writer("Writer 2", lock.writeLock()));
+
+    executeService.submit(writer1);
+    // Let write1 execute first
+    Thread.sleep(150);
+    executeService.submit(writer2);
+
+    executeService.shutdown();
+    try {
+      executeService.awaitTermination(10, TimeUnit.SECONDS);
+    } catch (InterruptedException e) {
+      System.out.println("Error waiting for ExecutorService shutdown");
+    }
+    // Write operation will hold the write lock 250 milliseconds, so here we verify that when two
+    // writer execute concurrently, the second writer can only writes only when the first one is
+    // finished.
+    final InOrder inOrder = inOrder(getStdOutMock());
+    inOrder.verify(getStdOutMock()).println("Writer 1 begin");
+    inOrder.verify(getStdOutMock()).println("Writer 1 finish");
+    inOrder.verify(getStdOutMock()).println("Writer 2 begin");
+    inOrder.verify(getStdOutMock()).println("Writer 2 finish");
+  }
+}