java线程条件变量_Java线程：条件变量 lock

条件变量是Java5线程中很重要的一个概念，顾名思义，条件变量就是表示条件的一种变量。但是必须说明，这里的条件是没有实际含义的，仅仅是个标记而已，并且条件的含义往往通过代码来赋予其含义。

这里的条件和普通意义上的条件表达式有着天壤之别。条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。

条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法，这样的处理不够精细。

而在Java5中，一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。有关Condition接口的API可以具体参考JavaAPI文档。

条件变量比较抽象，原因是他不是自然语言中的条件概念，而是程序控制的一种手段。

下面以一个银行存取款的模拟程序为例来揭盖Java多线程条件变量的神秘面纱：

有一个账户，多个用户(线程)在同时操作这个账户，有的存款有的取款，存款随便存，取款有限制，不能透支，任何试图透支的操作都将等待里面有足够存款才执行操作。

如果程序不使用synchronized关键字来保证同步,而直接用lock.那么系统中不存在隐式的同步监视器,就不能使用wait,notify,notifyAll方法进行线程通信了.但使用Lock对象来保证同步时,Java提供了一个Condition类来保持协调,使用Condition可以让那些已经得到Lock对象但无法继续执行的线程释放Lock对象,Condition对象也可以唤醒其他等待的线程.这情况下,Lock替代了同步方法或同步代码块,Condition替代了同步监视器的功能.

Condition实例绑定在Lock对象上,要获得需要调用Lock对象的newCondition方法.有3个方法:

await():类似于隐式同步监视器上的wait方法.该await方法有更多的重载方法.

signal():任意唤醒一个Lock对象上等待的单个线程.只有当前线程放弃对该Lock对象的锁定后(使用await()方法),才可以自行被唤醒的线程.

signalAll():唤醒所有等待线程。

package com.thread.lock;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class MyCount {

private String id; // 账号

private int cash; // 账户余额

private Lock lock = new ReentrantLock(); // 账户锁

private Condition _save = lock.newCondition(); // 存款条件

private Condition _draw = lock.newCondition(); // 取款条件

MyCount(String id, int cash) {

this.id = id;

this.cash = cash;

}

/**

* 存款

*

* @param name

* 存款人姓名

* @param cash

* 存款金额

*/

public void saving(String name, int saveCash) {

lock.lock();

if (saveCash > 0) {

cash += saveCash;

System.out.println(name + " 存款 " + saveCash + ",当前余额为" + cash);

}

_draw.signalAll(); // 唤醒所有等待线程。

lock.unlock(); // 释放锁

}

/**

* 取款

*

* @param name

* 取款人姓名

* @param cash

* 取款金额

*/

public void drawing(String name, int saveCash) {

lock.lock();

try {

if (cash < saveCash) {

_draw.await();

// 阻塞取款操作

} else {

cash -= saveCash;// 取款

System.out.println(name + " 取款 " + saveCash + ",当前余额为" + cash);

}

_save.signalAll(); // 唤醒所有存款操作

} catch (InterruptedException e) {

System.out.println(name + " 取款超额了" + " 取款金额为:" + saveCash);

// TODO Auto-generated catch block

// e.printStackTrace();

} finally {

lock.unlock();

}

}

}

class DrawThread extends Thread {

private String name; // 操作人

private MyCount myCount; // 账户

private int saveCash; // 存款金额

DrawThread(String name, MyCount myCount, int saveCash) {

this.name = name;

this.myCount = myCount;

this.saveCash = saveCash;

}

@Override

public void run() {

myCount.drawing(name, saveCash);

}

}

class SaveThread extends Thread {

private String name; // 操作人

private MyCount myCount; // 账户

private int saveCash; // 存款金额

SaveThread(String name, MyCount myCount, int saveCash) {

this.name = name;

this.myCount = myCount;

this.saveCash = saveCash;

}

@Override

public void run() {

myCount.saving(name, saveCash);

}

}

package com.thread.lock;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class TestLock {

public void run(){

ExecutorService pool = Executors.newFixedThreadPool(5);

MyCount count = new MyCount("43089183736746383", 1200);

SaveThread save1 = new SaveThread("张三",count, 200);

SaveThread save2 = new SaveThread("李四",count, 100);

DrawThread draw1 = new DrawThread("王五", count, 1600);

DrawThread draw2 = new DrawThread("赵六", count, 500);

SaveThread save3 = new SaveThread("王杰",count, 3000);

pool.execute(save1);

pool.execute(save2);

pool.execute(draw1);

pool.execute(draw2);

pool.execute(save3);

pool.shutdownNow();

}

public static void main(String[] args) {

new TestLock().run();

}

}