Added the skeleton for the concurrency lab

.gitignore

@@ -0,0 +1,3 @@
+.idea/*
+*.iml
+target/

README.md

@@ -0,0 +1,36 @@
+# TC-Concurrency
+
+## Monkey Typewriter
+According to Wikipedia:
+
+> The infinite monkey theorem states that a monkey hitting keys at random on a typewriter keyboard for an infinite 
+amount of time will almost surely type a given text.
+
+We don't have that kind of time, but what we do have are super smart monkeys.  These monkeys are able to copy text.
+
+So, guess what.  We're starting a printing company powered entirely off of monkey typists.
+
+### What to do!
+Testing multithreaded applications is super difficult.  Even more so, there's a chance that (if you're not actually
+testing things correctly) your tests will occasionally pass when they shouldn't (since a poorly threaded application
+isn't guaranteed to mess anything up).  Instead, we're going to use the main method in `Monkey Typewriter` to see
+exactly what happens when things are threaded incorrectly vs correctly.
+
+### Part 1
+
+Made for you is an abstract base class of `Copier` which has a constructor that takes a String and turns that into
+an iterator.  This will allow us to traverse the text to be copied and pass it along to each monkey (thread).
+
+Extend `Copier` in `UnsafeCopier`.  Then, write a `run` method that will have the monkey grab the next word and append
+it to the copy.
+
+Modify `MonkeyTypewriter` to create 5 monkeys (threads) using the `UnsafeCopier` and start them.
+
+After the sleep, print out the results of the unsafely copied passage.
+
+### Part 2
+
+Finish the `SafeCopier` and then call that from the main method, in addition to the unsafe version.
+
+
+

pom.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.zipcoder</groupId>
+    <artifactId>TC-Concurrency</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

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

@@ -0,0 +1,21 @@
+package io.zipcoder;
+
+import java.util.Arrays;
+import java.util.Iterator;
+
+/**
+ * We're using this as an abstract base class since both the safe and unsafe copiers will implement it.
+ */
+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) {
+        // 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

@@ -0,0 +1,38 @@
+package io.zipcoder;
+
+public class MonkeyTypewriter {
+    public static void main(String[] args) {
+        String introduction = "It was the best of times,\n" +
+                "it was the blurst of times,\n" +
+                "it was the age of wisdom,\n" +
+                "it was the age of foolishness,\n" +
+                "it was the epoch of belief,\n" +
+                "it was the epoch of incredulity,\n" +
+                "it was the season of Light,\n" +
+                "it was the season of Darkness,\n" +
+                "it was the spring of hope,\n" +
+                "it was the winter of despair,\n" +
+                "we had everything before us,\n" +
+                "we had nothing before us,\n" +
+                "we were all going direct to Heaven,\n" +
+                "we were all going direct the other way--\n" +
+                "in short, the period was so far like the present period, that some of\n" +
+                "its noisiest authorities insisted on its being received, for good or for\n" +
+                "evil, in the superlative degree of comparison only.";
+
+        // 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.
+
+
+        // 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.
+        try {
+            Thread.sleep(1000);
+        } catch(InterruptedException e) {
+            System.out.println("MAIN INTERRUPTED");
+        }
+
+        // Print out the copied versions here.
+    }
+}

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

@@ -0,0 +1,8 @@
+package io.zipcoder;
+
+/**
+ * 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 {
+}

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

@@ -0,0 +1,14 @@
+package io.zipcoder;
+
+/**
+ * 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() {
+    }
+}