@@ -0,0 +1,17 @@
+package com.brianway.learning.java.concurrent;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Created by brian on 16/11/30.
+ */
+public class CachedThreadPool {
+    public static void main(String[] args) {
+        ExecutorService exec = Executors.newCachedThreadPool();
+        for (int i = 0; i < 5; i++) {
+            exec.execute(new LiftOff());
+        }
+        exec.shutdown();
+    }
+}
@@ -0,0 +1,49 @@
+package com.brianway.learning.java.concurrent;
+
+import java.util.ArrayList;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+/**
+ * Created by brian on 16/11/30.
+ */
+public class CallableDemo {
+    public static void main(String[] args) {
+        ExecutorService exec = Executors.newCachedThreadPool();
+        ArrayList<Future<String>> results = new ArrayList<>();
+
+        for (int i = 0; i < 10; i++) {
+            results.add(exec.submit(new TaskWithResult(i)));
+        }
+
+        for (Future<String> fs : results) {
+            try {
+                System.out.println(fs.get());
+            } catch (InterruptedException e) {
+                System.out.println(e);
+                e.printStackTrace();
+            } catch (ExecutionException e) {
+                System.out.println(e);
+                e.printStackTrace();
+            } finally {
+                exec.shutdown();
+            }
+        }
+    }
+}
+
+class TaskWithResult implements Callable<String> {
+    private int id;
+
+    public TaskWithResult(int id) {
+        this.id = id;
+    }
+
+    @Override
+    public String call() throws Exception {
+        return "result of TaskWithResult  " + id;
+    }
+}
@@ -0,0 +1,59 @@
+package com.brianway.learning.java.concurrent;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+/**
+ * TODO 为什么有两个线程?
+ */
+public class CaptureUncaughtException {
+    public static void main(String[] args) {
+        ExecutorService exec = Executors.newCachedThreadPool(
+                new HandlerThreadFactory());
+        exec.execute(new ExceptionThread());
+    }
+}
+
+class ExceptionThread implements Runnable {
+    public void run() {
+        Thread t = Thread.currentThread();
+        System.out.println("run() by " + t);
+        System.out.println(
+                "eh = " + t.getUncaughtExceptionHandler());
+        throw new RuntimeException();
+    }
+}
+
+class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
+    public void uncaughtException(Thread t, Throwable e) {
+        System.out.println("caught " + e + " in " + t);
+    }
+}
+
+class HandlerThreadFactory implements ThreadFactory {
+    public Thread newThread(Runnable r) {
+        System.out.println(this + " creating new Thread");
+        Thread t = new Thread(r);
+        System.out.println("created " + t);
+        t.setUncaughtExceptionHandler(
+                new MyUncaughtExceptionHandler());
+        System.out.println(
+                "eh = " + t.getUncaughtExceptionHandler());
+        return t;
+    }
+}
+
+
+
+/* Output: (90% match)
+com.brianway.learning.java.concurrent.HandlerThreadFactory@266474c2 creating new Thread
+created Thread[Thread-0,5,main]
+eh = com.brianway.learning.java.concurrent.MyUncaughtExceptionHandler@6f94fa3e
+run() by Thread[Thread-0,5,main]
+eh = com.brianway.learning.java.concurrent.MyUncaughtExceptionHandler@6f94fa3e
+com.brianway.learning.java.concurrent.HandlerThreadFactory@266474c2 creating new Thread
+created Thread[Thread-1,5,main]
+eh = com.brianway.learning.java.concurrent.MyUncaughtExceptionHandler@3ff961b5
+caught java.lang.RuntimeException in Thread[Thread-0,5,main]
+*///:~
@@ -0,0 +1,30 @@
+package com.brianway.learning.java.concurrent;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Using a Thread Factory to create daemons.
+ */
+public class DaemonFromFactory implements Runnable {
+    public void run() {
+        try {
+            while (true) {
+                TimeUnit.MILLISECONDS.sleep(100);
+                System.out.println(Thread.currentThread() + " " + this);
+            }
+        } catch (InterruptedException e) {
+            System.out.println("Interrupted");
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        ExecutorService exec = Executors.newCachedThreadPool(
+                new DaemonThreadFactory());
+        for (int i = 0; i < 10; i++)
+            exec.execute(new DaemonFromFactory());
+        System.out.println("All daemons started");
+        TimeUnit.MILLISECONDS.sleep(500); // Run for a while
+    }
+} /* (Execute to see output) *///:~
@@ -0,0 +1,15 @@
+package com.brianway.learning.java.concurrent;
+
+import java.util.concurrent.ThreadFactory;
+
+/**
+ * Created by brian on 16/12/1.
+ */
+public class DaemonThreadFactory implements ThreadFactory {
+    @Override
+    public Thread newThread(Runnable r) {
+        Thread t = new Thread(r);
+        t.setDaemon(true);
+        return t;
+    }
+}
@@ -0,0 +1,37 @@
+package com.brianway.learning.java.concurrent;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Daemon threads don't run the finally clause
+ *
+ * output:"Starting ADaemon" or nothing
+ */
+
+public class DaemonsDontRunFinally {
+    public static void main(String[] args) throws Exception {
+        Thread t = new Thread(new ADaemon());
+        t.setDaemon(true);
+        t.start();
+    }
+}
+
+class ADaemon implements Runnable {
+    public void run() {
+        try {
+            System.out.println("Starting ADaemon");
+            TimeUnit.SECONDS.sleep(1);
+        } catch (InterruptedException e) {
+            System.out.println("Exiting via InterruptedException");
+        } finally {
+            System.out.println("This should always run?");
+        }
+    }
+}
+/* Output:
+Starting ADaemon
+
+or
+
+output nothing
+*///:~
@@ -0,0 +1,17 @@
+package com.brianway.learning.java.concurrent;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Created by brian on 16/11/30.
+ */
+public class FixedThreadPool {
+    public static void main(String[] args) {
+        ExecutorService exec = Executors.newFixedThreadPool(5);
+        for (int i = 0; i < 5; i++) {
+            exec.execute(new LiftOff());
+        }
+        exec.shutdown();
+    }
+}
@@ -0,0 +1,64 @@
+package com.brianway.learning.java.concurrent;
+
+/**
+ * Understanding join().
+ *
+ * 异常捕获时将清理标志位
+ */
+class Sleeper extends Thread {
+    private int duration;
+
+    public Sleeper(String name, int sleepTime) {
+        super(name);
+        duration = sleepTime;
+        start();
+    }
+
+    public void run() {
+        try {
+            sleep(duration);
+        } catch (InterruptedException e) {
+            System.out.println(getName() + " was interrupted. " +
+                    "isInterrupted(): " + isInterrupted());
+            return;
+        }
+        System.out.println(getName() + " has awakened");
+    }
+}
+
+class Joiner extends Thread {
+    private Sleeper sleeper;
+
+    public Joiner(String name, Sleeper sleeper) {
+        super(name);
+        this.sleeper = sleeper;
+        start();
+    }
+
+    public void run() {
+        try {
+            sleeper.join();
+        } catch (InterruptedException e) {
+            System.out.println("Interrupted");
+        }
+        System.out.println(getName() + " join completed");
+    }
+}
+
+public class Joining {
+    public static void main(String[] args) {
+        Sleeper
+                sleepy = new Sleeper("Sleepy", 1500),
+                grumpy = new Sleeper("Grumpy", 1500);
+        Joiner
+                dopey = new Joiner("Dopey", sleepy),
+                doc = new Joiner("Doc", grumpy);
+        grumpy.interrupt();
+    }
+}
+/* Output:
+Grumpy was interrupted. isInterrupted(): false
+Doc join completed
+Sleepy has awakened
+Dopey join completed
+*///:~
@@ -0,0 +1,29 @@
+package com.brianway.learning.java.concurrent;
+
+/**
+ * Created by brian on 16/11/30.
+ */
+public class LiftOff implements Runnable {
+    protected int countDown = 10;
+    private static int taskCount = 0;
+    private final int id = taskCount++;
+
+    public LiftOff() {
+    }
+
+    public LiftOff(int countDown) {
+        this.countDown = countDown;
+    }
+
+    public String status() {
+        return "#" + id + "(" + (countDown > 0 ? countDown : "LiftOff!") + "), ";
+    }
+
+    @Override
+    public void run() {
+        while (countDown-- > 0) {
+            System.out.print(status());
+            Thread.yield();
+        }
+    }
+}
@@ -0,0 +1,13 @@
+package com.brianway.learning.java.concurrent;
+
+/**
+ * Created by brian on 16/11/30.
+ */
+public class MoreBasicThreads {
+    public static void main(String[] args) {
+        for (int i = 0; i < 5; i++) {
+            new Thread(new LiftOff()).start();
+        }
+        System.out.println("Waiting for LiftOff");
+    }
+}