Java多线程实践—篇外篇

前面写了5篇关于多线程的知识点，看了一些面试题，发现是有遗漏，补充一下！另外多线程复杂多变，多练习、多看牛人代码才好！

1. 先说说捕获异常

由于线程的本质特性，使得不能捕获从线程中逃逸的异常。一旦异常逃出任务的run()方法，就会传播到控制台，除非用特殊的手段捕获这种错误异常。在Java SE5之前用线程组来捕获异常，Java SE5之后可以用Executor来解决。《Think in Java》用了8行字来介绍线程组，告诉读者：这就是个失败的作品！下面来看看一般情况下的异常抛出：

package zy.thread.demo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class ExceptionThread implements Runnable{public void run() {throw new RuntimeException();}public static void main(String[] args) {ExecutorService service = Executors.newCachedThreadPool();service.execute(new ExceptionThread());}}

运行可以看到：

Exception in thread "pool-1-thread-1" java.lang.RuntimeExceptionat zy.thread.demo.ExceptionThread.run(ExceptionThread.java:8)at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)at java.lang.Thread.run(Unknown Source)

将main中的代码放入try-catch块中也没有用。Executor可以解决问题。

首先得修改Executor产生线程的方式（默认是不支持捕获异常的）。Thread.UncaughtExceptionHandler（Java SE5新接口），允许在每个Thread对象上附着一个异常处理器。为了使用它，创建一个新类型ThreadFactory，它将在每个新创建的Thread对象上附着Thread.UncaughtExceptionHandler。然后将这个工厂传递给Executors创建的ExecutorService。下面是代码：

package zy.thread.demo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ThreadFactory;public class CaptureUncaughtException {public static void main(String[] args) {//设置默认的未捕获异常处理器//Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler());ExecutorService executor = Executors.newFixedThreadPool(1, new MyHandlerFactory());executor.execute(new ExceptionThread2());}}class ExceptionThread2 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 MyExceptionHandler implements Thread.UncaughtExceptionHandler {public void uncaughtException(Thread t, Throwable e) {System.out.println("caught " + e);}}class MyHandlerFactory implements ThreadFactory {public Thread newThread(Runnable r) {System.out.println(this + " creating new Thread");Thread thread = new Thread(r);System.out.println("created " + thread);//如果setUncaughtExceptionHandler没有参数，则默认会用线程组来捕获thread.setUncaughtExceptionHandler(new MyExceptionHandler());System.out.println("eh = " + thread.getUncaughtExceptionHandler());return thread;}}

2. 示例：“装饰性花园”

展示了如何用volatile布尔变量终止任务以及资源共享：一个花园有四扇门，现在花园委员会希望可以统计每天进入公园的人数，每个门都有一个计数器。

package zy.thread.demo;import java.util.ArrayList;import java.util.List;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;public class OrnamentalGarden {public static void main(String[] args) throws InterruptedException {ExecutorService executor = Executors.newCachedThreadPool();for (int i = 0; i < 5; i++)executor.execute(new Entrance(i));TimeUnit.SECONDS.sleep(1);Entrance.cancel();executor.shutdown();//如果在规定时间内所有任务都执行完毕，则返回true。否则返回falseif(!executor.awaitTermination(250, TimeUnit.MILLISECONDS))System.out.println("Some tasks were not terminated!");System.out.println("Total: " + Entrance.getTotalCount());System.out.println("Sum of Entrance " + Entrance.sumEntrance());}}class Count {private int count = 0;//private Random rand = new Random();public synchronized int increment() {//int temp = count;//if(rand.nextBoolean())//Thread.yield();//return (count = ++temp);return ++count;}public synchronized int value() { return count; }}class Entrance implements Runnable {private static Count count = new Count();private final int id;private static List<Entrance> list =new ArrayList<>();private int number = 0;private static volatile boolean canceled = false;public static void cancel() { canceled = true; }public Entrance(int id) {this.id = id;list.add(this);}public void run() {while (!canceled) {synchronized (this) {++number;}System.out.println(this + " : Total " + count.increment());try {TimeUnit.MILLISECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("Stopping " + this);}public synchronized int getValue() { return number; }public String toString() { return "Entrance " + id + ": " + getValue(); }public static int getTotalCount() { return count.value(); }public static int sumEntrance() {int sum = 0;for (Entrance entrance : list) {sum += entrance.getValue();}return sum;}}

代码中的count.increment()会增加失败的可能性，虽然可能性很小！虽然yield和sleep是不释放锁的，++temp虽然在synchronized块中，但也不是原子性操作！在实际coding中要尽量避免这类问题！

3. 本地线程

ThreadLocal类更像是一个变量，它为每一个线程存储一个值，因此根除了资源的竞争，不会出现竞争条件。ThreadLocal通常当做静态域存储，只能通过get()、set()方法来访问该对象内容。我们用ThreadLocal来重写上面的花园计数问题：

package zy.thread.demo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;public class MyThreadLocal {private static ThreadLocal<Integer> value = new ThreadLocal<Integer>() {protected synchronized Integer initialValue() {return 0;}};public static void increment() {value.set(value.get() + 1);}public static int get() { return value.get(); }public static void main(String[] args) throws InterruptedException {ExecutorService exec = Executors.newCachedThreadPool();for(int i = 0; i < 5; ++i)exec.execute(new MyEntrance(i));TimeUnit.SECONDS.sleep(3);MyEntrance.cancel();exec.shutdown();if(!exec.awaitTermination(250, TimeUnit.MILLISECONDS))System.out.println("Some tasks were not terminated!");}}class MyEntrance implements Runnable {private final int id;private int number = 0;private static volatile boolean canceled = false;public static void cancel() { canceled = true; }public MyEntrance(int id) {this.id = id;}public void run() {while (!canceled) {synchronized (this) {++number;}MyThreadLocal.increment();try {TimeUnit.MILLISECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("Stopping " + this);System.out.println(Thread.currentThread() + " Local " + MyThreadLocal.get());}public synchronized int getValue() { return number; }public String toString() { return "Entrance " + id + ": " + getValue(); }}

注意：MyEntrance的编号是从0开始，而Thread的编号是从1开始的，在比较结果是否正确的时候，请注意！

Stopping Entrance 2: 10Thread[pool-1-thread-3,5,main] Local 10Stopping Entrance 1: 10Thread[pool-1-thread-2,5,main] Local 10Stopping Entrance 0: 10Thread[pool-1-thread-1,5,main] Local 10Stopping Entrance 4: 10Thread[pool-1-thread-5,5,main] Local 10Stopping Entrance 3: 10Thread[pool-1-thread-4,5,main] Local 10

4. 死锁

看一个经典的例子：哲学家进餐问题。这个例子有两个参数很重要，哲学家思考的时间（ponder）、哲学家的数量（size），当ponder比较大或者size比较大时，表示他们花更多时间去思考，尽管存在死锁的可能，但是可能永远看不到死锁！当把ponder设置为0时，死锁很快就发生。下面是不会产生死锁的版本：

Chopstick.java

package zy.thread.demo;public class Chopstick {private boolean taken = false;public synchronized void take() throws InterruptedException {while(taken)wait();taken = true;}public synchronized void drop() {taken = false;notifyAll();}}

Philosopher.java

package zy.thread.demo;import java.util.Random;import java.util.concurrent.TimeUnit;public class Philosopher implements Runnable {private Chopstick right;private Chopstick left;private final int id;private final int ponderFactor;private Random rand = new Random(47);private void pause() throws InterruptedException {if (ponderFactor == 0) return;TimeUnit.MILLISECONDS.sleep(rand.nextInt(ponderFactor * 250));}public Philosopher(Chopstick right, Chopstick left, int id, int ponder) {this.right = right;this.left = left;this.id = id;this.ponderFactor = ponder;}public void run() {try {while (!Thread.interrupted()) {System.out.println(this + " " + "thinking");pause();System.out.println(this + " " + "grabbing right");right.take();System.out.println(this + " " + "grabbing left");left.take();System.out.println(this + " " + "eating");pause();right.drop();left.drop();}} catch (InterruptedException e) {e.printStackTrace();}}public String toString() { return "Philosopher " + id; }}

DeadlockingDiningPhilosophers.java

package zy.thread.demo;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class DeadlockingDiningPhilosophers {public static void main(String[] args) {int ponder = 0;int size = 5;ExecutorService service = Executors.newCachedThreadPool();Chopstick[] sticks = new Chopstick[size];for (int i = 0; i < size; i++)sticks[i] = new Chopstick();for (int i = 0; i < size; i++)if (i < size - 1)service.execute(new Philosopher(sticks[i], sticks[i + 1], i, ponder));elseservice.execute(new Philosopher(sticks[0], sticks[i], i, ponder));service.shutdown();}}

会产生死锁的版本只要修改DeadlockingDiningPhilosophers.java的第12行的for循环主体部分

service.execute(new Philosopher(sticks[i], sticks[(i + 1) % size], i, ponder));

5. 最后来看看Java是如何实现阻塞队列的（以ArrayBlockingQueue为例）

当我用offer()和poll()操作时，发现并不是线程安全的，而put()和take()发现却是线程安全的，这是为什么呢？来看看源码：

这是offer的（简单点，只看offer和put）

public boolean offer(E e) {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lock();        try {            if (count == items.length)                return false;            else {                insert(e);                return true;            }        } finally {            lock.unlock();        }    }

当发现队列慢的时候，直接返回false了，并没有等待，因此会出现不同步的现象，就像注释里说的

提示：在使用类似的并发集合时，一定要注意选择方法（先去看看API）！