Excellent beginner excercise, done

src/main/java/io/zipcoder/Copier.java

@@ -19,3 +19,10 @@ public abstract class Copier implements Runnable {
 
     public abstract void run();
 }
+
+/**Runnable is a interface,
+ * to implement runnable there is a method called run that gets implemented in the background
+ * and the copier class is abstract but it has a run method stubbed out which all of the
+ * subclasses have to implement. Unsafe and safe copier both have their own run method which are
+ * both slightly different.
+ */

src/main/java/io/zipcoder/MonkeyTypewriter.java

@@ -23,7 +23,30 @@ public class MonkeyTypewriter {
         // Do all of the Monkey / Thread building here
         // For each Copier(one safe and one unsafe), create and start 5 monkeys copying the introduction to
         // A Tale Of Two Cities.
+        UnsafeCopier badMonkey = new UnsafeCopier(introduction);
+       SafeCopier goodMonkey = new SafeCopier(introduction);
 
+        Thread unsafeWorker1 = new Thread(badMonkey);
+        Thread unsafeWorker2 = new Thread(badMonkey);
+        Thread unsafeWorker3 = new Thread(badMonkey);
+        Thread unsafeWorker4 = new Thread(badMonkey);
+        Thread unsafeWorker5 = new Thread(badMonkey);
+        Thread safeWorker1 = new Thread(goodMonkey);
+        Thread safeWorker2 = new Thread(goodMonkey);
+        Thread safeWorker3 = new Thread(goodMonkey);
+        Thread safeWorker4 = new Thread(goodMonkey);
+        Thread safeWorker5 = new Thread(goodMonkey);
+
+        unsafeWorker1.start();
+        unsafeWorker2.start();
+        unsafeWorker3.start();
+        unsafeWorker4.start();
+        unsafeWorker5.start();
+        safeWorker1.start();
+        safeWorker2.start();
+        safeWorker3.start();
+        safeWorker4.start();
+        safeWorker5.start();
 
         // This wait is here because main is still a thread and we want the main method to print the finished copies
         // after enough time has passed.
@@ -34,5 +57,21 @@ public class MonkeyTypewriter {
         }
 
         // Print out the copied versions here.
+        System.out.println(badMonkey.copied);
+        System.out.println("------------------------------------------------");
+        System.out.println(goodMonkey.copied);
     }
-}
+}
+
+
+/**
+ * created 1 instance of unsafe copier and I pushed it to 5 different threads. Called start on each thread
+ * what that does is everytime you tell a thread to start it dispatches to the background. Up until now
+ * everything running sequentially on main. Now think of main thread  trunk of a tree and it branches
+ * 5 times. What that means is that all those workers instead of running sequentially are going to run all at the same
+ * time. In unsafe copier method this instance is called once...there is only one copy of this instance and it's
+ * being called by 5 threads at the same time. Side effect of that is depending on the order in which the threads execute
+ * you will never have any control over the output. Inside unsafe copier there's a race condition---more than one process
+ * has access to the resource at the same time.
+
+ */

src/main/java/io/zipcoder/SafeCopier.java

@@ -1,8 +1,55 @@
 package io.zipcoder;
-
+import java.util.NoSuchElementException;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 /**
  * Make this extend the Copier like `UnsafeCopier`, except use locks to make sure that the actual intro gets printed
  * correctly every time.  Make the run method thread safe.
  */
-public class SafeCopier {
+public class SafeCopier extends Copier {
+    // stole this from here: http://www.baeldung.com/java-concurrent-locks
+    ReadWriteLock lock = new ReentrantReadWriteLock();
+    Lock writeLock = lock.writeLock();
+
+    public SafeCopier(String toCopy) {
+        super(toCopy);
+    }
+
+    public void run() {
+        try {
+            while (this.stringIterator.hasNext()) {
+                writeLock.lock();
+                this.copied += stringIterator.next() + " ";// + Thread.currentThread().getName();
+                writeLock.unlock();
+                Thread.sleep(10L);
+            }
+        }
+        catch (NoSuchElementException ex) {
+            this.copied += "FAIL ";
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
 }
+
+
+/**there's a variety of locks
+ * readwrite lock -- once you have the lock no else can read or write to it
+ * read lock -- uncommon if you have lock no can read it but can write to it
+ * write lock -most common if you have the lock you can't write to it but you can read it
+ * Want to keep locks locked as little as possible so program doesn't bog down. So put
+ * writeLock near the thing I want to protect. Once create lock the next thread that comes through and tries to
+ * grab the lock it can't so that thread stops and its halted. Once it unlocked all the threads fight for the lock.
+ * fight===> a whole bunch of memory shit I don't understand is working under the hood to control the thread scheduling.
+ *Also its up to the operating system, it s the operating system that gives you threads. This program could function
+ * differently on different computers.
+ * Once the thread is unlocked it goes to sleep for 10 milliseconds...the reason for that is that the same thread
+ * doesn't take the lock multiple times in row. Sort of like the guy who butts in line repeatedly at the buffet.
+ * YOu have to catch the interupted exception if you put a thread to sleep...the ide forces you to do it
+ * Had to add the interrupted exception in case.
+ *
+ * Replace this above the unlock  to get visibility into what threads are accessing the program
+ *  this.copied += Thread.currentThread().getName() + " ";
+ */
+

src/main/java/io/zipcoder/UnsafeCopier.java

@@ -1,14 +1,31 @@
 package io.zipcoder;
-
+import java.util.NoSuchElementException;
 /**
  * Modify the run function so that the monkeys each grab the next word and write it to the copy.
  */
 public class UnsafeCopier extends Copier {
 
     public UnsafeCopier(String toCopy) {
+
         super(toCopy);
     }
 
     public void run() {
+        try {
+            while (this.stringIterator.hasNext()) {
+                this.copied += this.stringIterator.next() + " ";
+            }
+        }
+        catch (NoSuchElementException ex) {
+            this.copied += "FAIL ";
+        }
     }
 }
+
+
+
+
+
+
+
+