Merge c96d7bc3c7ab831034e6be11834abcb099f29286 into dbc7033eb3d6c33c19985384bea0b1a977cc30d3

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

@@ -12,10 +12,11 @@ public abstract class Copier implements Runnable {
     public String copied;
 
     public Copier(String toCopy) {
-        // Take the input string, split it on spaces, turn that array to an arraylist, and then grab its iterator.
+        // Take the input string, split it on spaces, turn that array to an arrayList, and then grab its iterator.
         this.stringIterator = Arrays.asList(toCopy.split(" ")).iterator();
         this.copied = "";
     }
 
     public abstract void run();
+
 }

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

@@ -23,7 +23,22 @@ 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 unsafe = new UnsafeCopier(introduction);
+        Thread[] threads = new Thread[5];
+        for(int i = 0; i < threads.length; i++){
+            threads[i] = new Thread(unsafe);
+        }
+        for(Thread t : threads){
+            t.start();
+        }
+        SafeCopier safeCopier = new SafeCopier(introduction);
+        Thread[] threads2 = new Thread[5];
+        for(int i = 0; i < threads2.length; i++){
+             threads2[i] = new Thread(safeCopier);
+        }
+        for(Thread t2 : threads2){
+            t2.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.
@@ -32,7 +47,8 @@ public class MonkeyTypewriter {
         } catch(InterruptedException e) {
             System.out.println("MAIN INTERRUPTED");
         }
-
+        System.out.println(unsafe.copied);
+        System.out.println(safeCopier.copied);
         // Print out the copied versions here.
     }
 }

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

@@ -1,8 +1,34 @@
 package io.zipcoder;
 
+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{
+
+    ReentrantLock lock = new ReentrantLock();
+
+    public SafeCopier(String toCopy) {
+        super(toCopy);
+    }
+
+    public void run() {
+        lock.lock();
+//        try{
+//            Thread.sleep(30);
+//        }catch (InterruptedException e){
+//            e.printStackTrace();
+//        }
+        if(stringIterator.hasNext()){
+           StringBuilder sb = new StringBuilder();
+           String s = stringIterator.next();
+           sb.append(s);
+
+            copied = copied + sb.toString() + " ";
+            }
+            lock.unlock();
+
+    }
 }

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

@@ -1,14 +1,31 @@
 package io.zipcoder;
 
+import java.util.Iterator;
+
 /**
  * Modify the run function so that the monkeys each grab the next word and write it to the copy.
  */
 public class UnsafeCopier extends Copier {
-
+    // We use an iterator so each monkey / thread can copy an individual word.
+//    public Iterator<String> stringIterator;
+//    public String copied;
     public UnsafeCopier(String toCopy) {
         super(toCopy);
     }
 
     public void run() {
+        try {
+            Thread.sleep(60);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        if (stringIterator.hasNext()) {
+            StringBuilder sb = new StringBuilder();
+            String s = stringIterator.next();
+            sb.append(s);
+
+            copied = copied + sb.toString() + " " + Thread.currentThread().getName();
+        }
     }
 }
+