java 多线程 对象_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是将全部的等待线程都唤醒。

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