java 多线程（三）条件对象

转载请注明出处：http://blog.csdn.net/xingjiarong/article/details/47417383
在上一篇博客中，我们学会了用ReentrantLock来控制线程访问同一个数据，防止出现Race Condition。这一次呢，我们继续深入的学习，学习一下java中的条件对象，条件对象在多线程同步中用到的比较多。

首先，我们来介绍一下临界区。

临界区：在同步的程序设计中，临界区指的是一个访问共用资源的程序片段，而这些共用资源又具有无法同时被多个线程访问的特性。 当有线程进入临界区时，其他线程或是进程必须等待，在一些情况下必须在临界区的进入点与离开点采用一些特殊的方法，以确保这些共用资源是被互斥使用的。

现在我们来看一个新的例子,这是一个银行转账的例子。在Bank类中，我们声明了一个10个大小的数组，用来表示银行中的10个账户，而对应的数值就是这个账户中对应的金额。Bank类提供了转移账户资金的方法，可以从from账户，转移amount的资金到to账户。还提供了获得这些账户的总金额的方法，getTotalBalabce（），因为资金转移是发生在这10个账户中的，所以无论怎样转移，总的金额应该是不变的。

Bank.java

import java.util.concurrent.locks.ReentrantLock;

public class Bank {
    /**
     * 利用数组模拟银行账户
     */
    private final double accounts[];
    private ReentrantLock lock = new ReentrantLock();

    public Bank() {
        accounts = new double[10];
        /*
         * 初始化，使每个账户都初始有initialBalance金钱
         */
        for (int i = 0; i < 10; i++)
            accounts[i] = 1000;
    }

    /**
     * 资金转移的方法
     * 
     * @param from
     *            源账户
     * @param to
     *            目标账户
     * @param amount
     *            转移金额
     */
    public void transfer(int from, int to, double amount) {
        lock.lock();
        try {
            if (accounts[from] < amount)
                return
            System.out.print(Thread.currentThread());
            accounts[from] -= amount;
            System.out.printf("%5.2f from %d to %d", amount, from, to);
            accounts[to] += amount;
            System.out.printf(" Total Balance:%5.2f\n", getTotalBalance());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 获取所有账户的总金额
     * 
     * @return
     */
    public double getTotalBalance() {
        lock.lock();
        double sum = 0;
        try {

            for (double a : accounts)
                sum += a;
        } finally {
            lock.unlock();
        }
        return sum;
    }

    /**
     * 获取现在账户的数量
     * 
     * @return
     */
    public int size() {
        return accounts.length;
    }
}

TransferRunnable这个类实现了Runnable接口，我们在Main函数中拿他做线程，它的run方法就是产生一个随机的目标账户和转移的金额，然后调用Bank类的方法将资金转移到目标账户中去。

TransferRunnable.java

public class TransferRunnable implements Runnable{

    private Bank bank;
    private int fromAccount;

    public TransferRunnable(Bank b,int from){
        bank=b;
        fromAccount=from;
    }

    public void run(){
        try{
            while(true)
            {
                int toAccount = (int)(bank.size()*Math.random());
                double amount = 1000*Math.random();
                bank.transfer(fromAccount, toAccount, amount);
                Thread.sleep(1000);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }   
}

在主程序中，我们创建了10个线程，每一个线程都从一个对应的账户转移一定的资金到随机的账户中去。
Main.java

public class Main {

    public static void main(String[] args) {
        Bank b = new Bank();
        Thread[] threadArray = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArray[i] = new Thread(new TransferRunnable(b, i));
        }

        for(int i=0;i<10;i++){
            threadArray[i].start();
        }
    }

}

在这个程序中有共同的变量——10个银行账户的资金，所以就有对应的临界区——Bank类的transfer方法和getTotalBalabce方法，如果不对临界区加以保护的话，会导致多个线程同时进入临界区，而导致结果错误，读者可以试验一下，将ReentrantLock加锁的地方都去掉，看看总金额是不是会产生变化，在我的试验中，不但总金额的数量不对，就连打印的语句顺序都是不对的，说明一个线程在System.out.printf()的过程中都被别的线程打断了。

看了这个例子，相信大家对ReentrantLock的使用更加熟练了。

现在我们来考虑这样一个问题，大家看到transfer方法中，如果账户中的金额不足的时候就立刻返回而不再发生资金转移，我现在不想这样处理了。我想要这样处理，如果账户资金不足的话，就一直等待，直到其他的账户向这个账户转移足够的资金了，然后再发生资金转移。

问题是，操作这个账户的线程已经获得了lock，其他的线程无法再进入lock方法，也就不可能向这个账户转移相应的资金了，所以说，这个线程必须放弃lock的控制权，让其他的线程获得。

Java中提供了条件对象，Condition类，来配合ReentrantLock实现对临界区的控制，我们对Bank类做下面的改变。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Bank {
    /**
     * 利用数组模拟银行账户
     */
    private final double accounts[];
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition;

    public Bank() {
        accounts = new double[10];
        /*
         * 初始化，使每个账户都初始有initialBalance金钱
         */
        for (int i = 0; i < 10; i++)
            accounts[i] = 1000;

        condition = lock.newCondition();
    }

    /**
     * 资金转移的方法
     * 
     * @param from
     *            源账户
     * @param to
     *            目标账户
     * @param amount
     *            转移金额
     */
    public void transfer(int from, int to, double amount) {
        lock.lock();
        try {
            while (accounts[from] < amount)
                condition.await();
            System.out.print(Thread.currentThread());
            accounts[from] -= amount;
            System.out.printf("%5.2f from %d to %d", amount, from, to);
            accounts[to] += amount;
            System.out.printf(" Total Balance:%5.2f\n", getTotalBalance());
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 获取所有账户的总金额
     * 
     * @return
     */
    public double getTotalBalance() {
        lock.lock();
        double sum = 0;
        try {

            for (double a : accounts)
                sum += a;
        } finally {
            lock.unlock();
        }
        return sum;
    }

    /**
     * 获取现在账户的数量
     * 
     * @return
     */
    public int size() {
        return accounts.length;
    }
}

首先，声明了一个Condition类的对象引用变量condition，在Bank的构造方法中进行的初始化，初始化是是调用的ReentrantLock类的方法newCondition（），说明Condition对象时依赖于ReentrantLock对象的，一个ReentrantLock对象可以创建多个条件对象，名字通常以控制的条件来命名。

然后在transfer方法中，下面两行是关键：

while (accounts[from] < amount)
    condition.await();

用while循环检测账户的余额，如果余额不足就调用await（）方法，await（）会阻塞线程，并释放线程保持的锁，这时其他的线程就可以进入临界区了，当账户的余额满足条件时，等待的线程也不会主动的唤醒，直到有一个线程调用了signalAll（）方法。signalAll（）方法唤醒所有因为不满足条件而等待的线程，但是线程不一定能够继续向下执行，因为signalAll（）唤醒线程时，并不是告诉线程你的条件满足了，可以继续向下执行了，而是告诉线程，现在条件改变，你可以重新检测条件是否满足了。如果条件被满足，那么也只有一个线程能够继续向下执行，因为一旦一个对象获得了临界区的锁，其他的线程就不能再进入临界区了。那么应当什么时候调用signalAll（）方法呢，从经验上将应该在对象的状态有利于等待线程的方向改变时调用。这里我们再发生资金转移后调用，因为资金转移后，其他的线程有可能满足条件了。

注意：通常，await（）的调用应该在如下形式的循环体中：

while(!(ok to proceed))
    condition.await();

这里的while循环不能换成if条件语句，因为被别的线程用signalAll方法唤醒的线程，仅仅是条件可能满足了，而不是条件一定满足了，如果不用while循环继续检测的话，就会造成条件不满足的线程继续向下执行，从而产生错误。

当一个线程拥有某个条件的锁时，它仅仅可以在该条件上调用await（），signalAll（），signal（）这三个方法，现在我们讲讲第三个方法。

signal和signalAll的区别是，signal不会将全部的等待线程唤醒，而是随机选择一个线程唤醒，而signalAll是将全部的等待线程都唤醒。

最后附上源码：http://download.csdn.net/detail/xingjiarong/9010675

在下一篇博客里，我会为大家介绍java的synchronized关键字，希望与大家一起学习一起进步，请大家继续关注我的博客，如果大家支持我的话，就顶我一下吧。