Merge 3b93fcfedfb2d936f0376e7aad4165a73da39bd5 into dbc7033eb3d6c33c19985384bea0b1a977cc30d3

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

@@ -23,7 +23,32 @@ 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.
+        Copier copier = new SafeCopier(introduction);
+        Thread thread1 = new Thread(copier);
+        Thread thread2 = new Thread(copier);
+        Thread thread3 = new Thread(copier);
+        Thread thread4 = new Thread(copier);
+        Thread thread5 = new Thread(copier);
 
+        Copier copiers = new UnsafeCopier(introduction);
+        Thread thread11 = new Thread(copiers);
+        Thread thread22 = new Thread(copiers);
+        Thread thread33 = new Thread(copiers);
+        Thread thread44 = new Thread(copiers);
+        Thread thread55 = new Thread(copiers);
+
+        thread1.start();
+        thread2.start();
+        thread3.start();
+        thread4.start();
+        thread5.start();
+
+
+        thread11.start();
+        thread22.start();
+        thread33.start();
+        thread44.start();
+        thread55.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 +59,8 @@ public class MonkeyTypewriter {
         }
 
         // Print out the copied versions here.
+        System.out.println(copier.copied);
+        System.out.println(copiers.copied);
+
     }
 }

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

@@ -1,8 +1,38 @@
 package io.zipcoder;
 
+import java.util.NoSuchElementException;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 /**
  * 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{
+    private Lock lock;
+
+    public SafeCopier(String toCopy) {
+        super(toCopy);
+        lock = new ReentrantLock();
+    }
+
+    public void run() {
+        try{
+            lock.lock();
+            copied += stringIterator.next() + " " + Thread.currentThread().getName()+ " ";
+        } catch (NoSuchElementException e){
+
+        } finally {
+            lock.unlock();
+        }
+    }
 }
+
+//Explanation/PseudoCode
+//created a private lock field with type lock
+//inorder to fully extend Copier had to override Copier constructor and methods
+//instantiated the lock (looked at the lecture for the "new ReentrantLock()"
+//try and catch for exception handling
+//NoSuchElementException  =  indicates that there are no more elements in the enumeration.
+//finally - The finally block always executes when the try block exits.
+//then I unlocked the lock

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

@@ -6,9 +6,26 @@ package io.zipcoder;
 public class UnsafeCopier extends Copier {
 
     public UnsafeCopier(String toCopy) {
+
         super(toCopy);
     }
 
     public void run() {
+        while(stringIterator.hasNext()){
+            copied += stringIterator.next()+" ";
+        }
     }
 }
+
+//PseudoCode
+//loop through the array in copier.java
+// monkey needs to grab the next word
+//append it to the copy
+//monkeytypewriter will create 5 monkey(threads) and use this class to start them
+
+//Ex of run method
+//tried a for loop initially and couldn't figure out what should be in the comparable part
+//so while stringIterator(which was turned into an arraylist in copier.java) knows our iteration
+//has more elements, then add the stringIterators next value to copied plus the space.
+
+