done?

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

@@ -9,6 +9,7 @@ import java.util.Iterator;
 public abstract class Copier implements Runnable {
     // We use an iterator so each monkey / thread can copy an individual word.
     public Iterator<String> stringIterator;
+
     public String copied;
 
     public Copier(String toCopy) {

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

@@ -20,9 +20,35 @@ public class MonkeyTypewriter {
                 "its noisiest authorities insisted on its being received, for good or for\n" +
                 "evil, in the superlative degree of comparison only.";
 
+        StringBuilder sb = new StringBuilder();
+        for(int i = 0; i < 500; i++){
+            sb.append(introduction + " ");
+        }
+        String big = sb.toString();
         // 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);
+        SafeCopier safe = new SafeCopier(introduction);
+
+        SafeCopier bigSafe = new SafeCopier(big);
+
+
+        for(int i = 0; i < 5; i++){
+            new Thread(unsafe).start();
+        }
+
+        for(int i = 0; i < 5; i++){
+            new Thread(safe).start();
+        }
+
+//        for(int i = 0; i < 5; i++){
+//            new Thread(bigSafe).start();
+//        }
+
+
+
+
 
 
         // This wait is here because main is still a thread and we want the main method to print the finished copies
@@ -33,6 +59,10 @@ public class MonkeyTypewriter {
             System.out.println("MAIN INTERRUPTED");
         }
 
+        System.out.println(unsafe.copied);
+        System.out.println("============");
+        System.out.println(safe.copied);
+        //System.out.println(bigSafe.copied);
         // Print out the copied versions here.
     }
 }

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

@@ -1,8 +1,31 @@
 package io.zipcoder;
 
+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{
+
+    Lock lock = new ReentrantLock();
+
+    public SafeCopier(String toCopy){
+        super(toCopy);
+    }
+
+    public void run(){
+
+        while(stringIterator.hasNext()){
+            lock.lock();
+            //System.out.println("curr thread :" + Thread.currentThread().getName());
+            copied += stringIterator.next() + " ";
+            lock.unlock();
+        }
+        //System.out.println("curr thread :" + Thread.currentThread().getName());
+
+    }
+
+
 }

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

@@ -10,5 +10,11 @@ public class UnsafeCopier extends Copier {
     }
 
     public void run() {
+        while (stringIterator.hasNext()) {
+            //System.out.println(Thread.currentThread().getName());
+            copied += stringIterator.next() + " ";
+            //copied += " ";
+        }
+        //copied += stringIterator.next() + " ";
     }
 }