线程基础：JDK1.5+（8）——线程新特性（上）

1、概要

假设您阅读JAVA的源码。出现最多的代码作者包含：Doug Lea、Mark Reinhold、Josh Bloch、Arthur van Hoff、Neal Gafter、Pavani Diwanji等等。当中java.util.concurrent包中出现的基本都是Doug Lea的名字。Doug Lea。是对Java影响力最大的个人。直接贡献的设计包含java的Collections和util.concurrent。

JDK1.5中一个重要特性就是util.concurrent包和其子包（当让JDK1.5中的特性还包含了非常多，比如泛型、解包/封包等，但这些不属于我们这个专题讨论的范围）。

在这个系列的专题中。我们已经对util.concurrent包中的一些主要功能做了介绍。比如：BlockingQueue、ThreadPoolExecutor、Executors等。

这篇文章中，我们对这个包中其它中要的线程特性进行介绍。

2、带返回值的Callable

在之前的文章中，我们提到JAVA线程相关的Runnable接口中的run()方法没有提供返回值。例如以下：

......
public void run() {
    ......
}
......

假设您须要在线程A运行完毕，得到返回值后，再继续运行某个业务。

那么推荐您使用JDK1.5中提供的带有“运行返回值”的线程定义接口：Callable。

假设您还须要为多个线程的运行调度增加更复杂的控制逻辑，那么您须要我们之前讨论过的同步机制和JDK1.5中java.util.concurrent.locks包中的工具配合使用，才干达到效果。

JDK1.5的java.util.concurrent包中提供了一个Callable接口和一组相关机制，能够帮助程序猿安全、高速、简洁的完毕以上的功能（线程运行完毕后，返回一个运行结果）。Callable接口中须要实现的接口方法为call()，这种方法有一个泛化的返回值 V，能够帮助您返回定义的不论什么一种对象结果。接口源码例如以下：

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

下面我们通过一段简单的代码，看一下Callable接口是怎样完毕运行结果的返回和激活等待线程的：

package test.thread.base.callfurther;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * 測试可监控状态的线程
 * @author yinwenjie
 * @param <V>
 */
public class MyCallableThread<V extends Entity> implements Callable<V> {

    private V resultsEntity;

    public MyCallableThread(V param) {
        this.resultsEntity = param;
    }

    /* (non-Javadoc)
     * @see java.util.concurrent.Callable#call()
     */
    @Override
    public V call() throws Exception {
        try {
            // 等待一段时间，模拟业务运行过程
            synchronized (this) {
                this.wait(5000);
            }
            // 设置返回结果
            this.resultsEntity.setStatus(1);
        } catch(Exception e) {
            // 运行错误了。也设置
            this.resultsEntity.setStatus(-1);
        }

        return this.resultsEntity;
    }

    public static void main(String[] args) throws Exception {
        //这是您定义的一个模型对象。里面有一个status属性
        MyCallableThread<Entity> callableThread = new MyCallableThread<Entity>(new Entity());

        // Callable须要在线程池中运行
        ExecutorService es = Executors.newFixedThreadPool(1);
        Future<Entity> future = es.submit(callableThread);

        // main线程会在这里等待，知道callableThread任务运行完毕
        Entity result = future.get();
        System.out.println("result.status = " + result.getStatus());
        // 停止线程池工作
        es.shutdown();
        es.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
    }
}

从以上给出的使用代码，包含下面几个实际动作：

• Entity这个class，是为了记录线程运行的返回结果由我们自行定义的一个Class。

  实际上，对于MyCallableThread来说，仅仅要继承了Entity的全部子类，都是能够作为它的泛化值的。

• 眼下Callable定义的线程任务，仅仅能放入线程池中，由线程池中的任务进行运行。没有相似于Runnable接口那样。new Thread(new MyDefindRunnable())而且start()的线程运行方式。

  • 假设您不想使用线程池管理任务的运行，又不能直接将Callable接口的任务放入Thread，那么您仅仅能借助一个工具类：FutureTask。

    使用方式例如以下：

FutureTask<Entity> futureTask = new FutureTask<Entity>(callableThread);
new Thread(futureTask).start();

• Future用于描写叙述当前任务线程的运行状态。您能够使用isDone、isCancelled等方法，来获取当前任务线程的运行状态。

• Future接口中的get方法。将会是当前线程进入堵塞状态。

  直到目标线程运行完毕。而且得到目标线程的返回结果。

Waits if necessary for the computation to complete, and then retrieves its result.

Returns: the computed result
Throws:
CancellationException - if the computation was cancelled
ExecutionException - if the computation threw an exception
InterruptedException - if the current thread was interrupted while waiting

3、JDK新特性锁：java.util.concurrent.locks包

java.util.concurrent有一个locks子包。这个子包提供了一种JDK1.5版本号中设计的一种新的锁机制。当中重要的包含两种类型的锁：ReentrantLock通用锁和ReentrantReadWriteLock读写锁。这个小结我们主要介绍这两种新得锁形态的使用。

3-1、Lock->ReentrantLock通用锁

在JDK1.5版本号中。Doug Lea增加了两种新的对象锁方式，ReentrantLock和ReentrantReadWriteLock。

在之前的版本号中，假设我们要为某个线程中操作的对象加锁，写法例如以下：

......
synchronized (ThreadLock.WAIT_OBJECT) {
    ThreadLock.LOGGER.info("做了一些事情。。。。
");
}
......

这个须要加锁的对象进行同步检查，同步边界内的代码仅仅同意某一条线程A进入。除非线程A退出了同步边界或者通过wait等方法进入了堵塞状态，这段代码才同意其它线程訪问。

在使用synchronized关键字的时候，您还须要特别关注interrupt异常。实际上这是由于JVM不同意停止“正在等待同步锁”的线程（这是更深入的知识点了）。

那么假设您使用ReentrantLock为多个线程在共享资源的线程块进行堵塞控制。就要比使用synchronized关键字简单很多（至少从表面现象来看是这样的），而且您不须要特别关注interrupt异常（至少从表面现象来看是这样的）。

还记得我们在《线程基础：线程（2）——JAVA中的基本线程操作（上） 》这篇文章中，给出的一段在多线程情况下使用对象锁的最简单代码吗？没事，不用特意去翻这篇文章。这里我们再给出一次即可了（为了节约篇幅，仅仅给重要的代码片段）：

......
/**
 * 拿来加锁的对象
 */
private static final Object WAIT_OBJECT = new Object();
......

Thread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        // 检查'对象锁'状态。
        synchronized (ThreadLock.WAIT_OBJECT) {
            ThreadLock.LOGGER.info("做了一些事情。。。
。");
        }
    }
});

Thread threadB = new Thread(new Runnable() {
    @Override
    public void run() {
        // 检查'对象锁'状态。
        synchronized (ThreadLock.WAIT_OBJECT) {
            ThreadLock.LOGGER.info("做了还有一些事情。。
。。
");
        }
    }
});
threadA.start();
threadB.start();
......

如今我们使用ReentrantLock方式，对之前这段代码进行更改：

......
public void test() {
    final ReentrantLock objectLock = new ReentrantLock();

    new Thread() {
        public void run() {
            objectLock.lock();
            TestReentrantLock.LOG.info("做了一些事情。。
。。");
            objectLock.unlock();
        }
    }.start();

    new Thread() {
        public void run() {
            objectLock.lock();
            TestReentrantLock.LOG.info("做了还有一些事情。
。。
。");
            objectLock.unlock();
        }
    }.start();
}
......

非常显然，下面使用ReentrantLock方式改写后的代码是不是好理解多了。

实际上最直观的理解就是将synchronized关键字的边界换成了 lock和unlock方法（但其实并不是如此）。至少线程您不须要关心interrupt异常了。

3-2、ReadWriteLock->ReentrantReadWriteLock读写锁

在java.util.concurrent.locks包中。还提供了一个ReentrantReadWriteLock工具。非常显然，依据这个类的名字就明确了它的含义，即将多个线程对指定对象的读操作和写操作分开加锁。

我们能够使用下面代码，来获取对象的写锁

WriteLock writeLock = objectLock.writeLock();

使用下面代码。来获取对象的读锁：

ReadLock readLock = objectLock.readLock();

那么对象的写锁和读锁是怎么互相影响的呢？这个须要分开进行描写叙述，首先我们来讨论一下，什么情况下线程能够获取某个对象的读锁：

• 假设没有不论什么线程获取了对象的写锁。

• 尽管有线程获取了对象的写锁。可是这个线程就是当前请求读锁的线程

那么当前是否有线程获取了对象的读锁。并不会影响当前线程继续获取对象的读锁。什么情况下线程能够获取某个对象的写锁：

• 没有不论什么线程获取了这个对象的读锁
• 没有不论什么线程获取了这个对象的写锁

注意，这里没有“尽管”的说法。也就是说，在同一个线程中的下面这样的写法将会导致死锁：

......
ReadLock readLock = objectLock.readLock();
readLock.lock();
WriteLock writeLock = objectLock.writeLock();
// 线程操作会被一直堵塞在这里
writeLock.lock();
......

可是，同一个线程中的下面这样的写法，就没有问题：

......
WriteLock writeLock = objectLock.writeLock();
writeLock.lock();
ReadLock readLock = objectLock.readLock();
readLock.lock();
......

下面是全部演示样例代码：

package test.thread.reentrant;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.BasicConfigurator;

public class TestReadWriteReentrantLock {

    static {
        BasicConfigurator.configure();
    }

    /**
     * 日志
     */
    private static final Log LOG = LogFactory.getLog(TestReadWriteReentrantLock.class);

    public static void main(String[] args) throws RuntimeException {
        new TestReadWriteReentrantLock().test();
    }

    public void test() {
        final ReentrantReadWriteLock objectLock = new ReentrantReadWriteLock();

        Thread thread1 = new Thread() {
            public void run() {
                WriteLock writeLock = objectLock.writeLock();
                writeLock.lock();
                TestReadWriteReentrantLock.LOG.info("做了一些写操作的事情。。
。。");
                writeLock.unlock();
            }
        };


        Thread thread2 = new Thread() {
            public void run() {
                WriteLock writeLock = objectLock.writeLock();
                writeLock.lock();
                TestReadWriteReentrantLock.LOG.info("做了还有一些写操作的事情。。。。");
                writeLock.unlock();
            }
        };

        Thread thread3 = new Thread() {
            public void run() {
                ReadLock readLock = objectLock.readLock();
                readLock.lock();
                TestReadWriteReentrantLock.LOG.info("做了一些读操作的事情。。
。
。");
                readLock.unlock();
            }
        };

        //thread1、thread2、thread3在运行过程中，将依照我们之前描写叙述的规律，相互作用
        thread1.start();
        thread2.start();
        // 您能够使用thread1.interrupt()指令对ReentrantLock的影像。
        // 您能够发现，thread1在加锁后并不会抛出interruptException异常
        // 至少在我们这样的使用方式下，不会抛出异常
        // thread1.interrupt();
        thread3.start();
    }
}

这里要重点说明一下。在大多数情况下您使用sycnchronized关键字或者使用ReentrantLock方式。都没有问题（这是由于90%的情况下，sycnchronized并不会真正的堵塞）。

全然没有必要为了使用性能更好的ReentrantLock方式，而改变您历史代码版本号中的sycnchronized关键字。

兴许假设有时间。我将和大家讨论sycnchronized方式和ReentrantLock方式在工作原理上的不同。可是由于我在这个专栏上耗费了太多时间，所以仅仅有暂缓。

假设您想立即深入理解他们的工作原理，这里我推荐一篇文章：（http://www.ibm.com/developerworks/library/j-jtp10264/）

下文中，我们将以一个“赛跑”的样例，解说JDK1.5环境下一些线程控制工具（包含Semaphore、CountDownLatch和java.util.concurrent.atomic子包）。而且复习这个专题讲到的知识点：同步快、锁、线程池、BlockingQueue、Callable等。

当然还有线程间数据传递的方式。

（接下文）