Condition 將 Object 監視器方法（wait、notify 和 notifyAll）分解成截然不同的對象，以便通過將這些對象與任意 Lock 實現組合使用，為每個對象提供多個等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和語句的使用，Condition 替代了 Object 監視器方法的使用。
先看一個關於Condition使用的簡單實例：
public class ConditionTest {
public static void main(String[] args) {
final Lock lock = new ReentrantLock();
final Condition condition = lock.newCondition();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
System.out.println("我需要等一個信號"+this);
condition.await();
System.out.println("我拿到一個信號"+this);
} catch (Exception e) {
// TODO: handle exception
} finally{
lock.unlock();
}
}
}, "thread1");
thread1.start();
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
lock.lock();
System.out.println("我拿到了鎖");
Thread.sleep(500);
System.out.println("我發出一個信號");
condition.signal();
} catch (Exception e) {
// TODO: handle exception
} finally{
lock.unlock();
}
}
}, "thread2");
thread2.start();
}
}
運行結果：
1 我需要等一個信號com.luchao.traditionalthread.ConditionTest$1@10bc3c9
2 我拿到了鎖
3 我發出一個信號
4 我拿到一個信號com.luchao.traditionalthread.ConditionTest$1@10bc3c9
可以看到，Condition的執行方式，是當在線程1中調用await方法後，線程1將釋放鎖，並且將自己沉睡，等待喚醒，線程2獲取到鎖後，開始做事，完畢後，調用Condition的signal方法，喚醒線程1，線程1恢復執行。
以上說明Condition是一個多線程間協調通信的工具類，使得某個，或者某些線程一起等待某個條件（Condition）,只有當該條件具備( signal 或者 signalAll方法被帶調用)時 ，這些等待線程才會被喚醒，從而重新爭奪鎖。
Condition與傳統線程通信有些類似，它的使用更廣，可以將多個線程進行通信，以完成更加復雜的通信。
用Condition替換傳統線程通信，在前面的傳統有一個子線程和主線程交替運行50次的實例，使用Condition也可以完成。
代碼如下：
public class ConditionCommuniction {
public static void main(String[] args) {
final Business business = new Business();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
business.sub(i);
}
}
}).start();
for (int i = 0; i < 50; i++) {
business.main(i);
}
}
static class Business{
private Lock lock = new ReentrantLock();
private boolean isMain = true;
private Condition condition = lock.newCondition();
public void main(int i){
lock.lock();
try {
while(!isMain){
condition.await();
}
for (int j = 0; j < 100; j++) {
System.out.println("main is looping :" + j +" in " + i);
}
isMain = false;
condition.signal();
} catch (Exception e) {
// TODO: handle exception
} finally{
lock.unlock();
}
}
public void sub(int i){
lock.lock();
try {
while(isMain){
condition.await();
}
for (int j = 0; j < 10; j++) {
System.out.println("sub is looping :" + j +" in " + i);
}
isMain = true;
condition.signal();
} catch (Exception e) {
// TODO: handle exception
} finally{
lock.unlock();
}
}
}
}
在Condition中，用await()替換wait()，用signal()替換notify()，用signalAll()替換notifyAll()，傳統線程的通信方式，Condition都可以實現，這裡注意，Condition是被綁定到Lock上的，要創建一個Lock的Condition必須用newCondition()方法。
這樣看來，Condition和傳統的線程通信沒什麼區別，Condition的強大之處在於它可以為多個線程間建立不同的Condition，下面引入API中的一段代碼，加以說明。
class BoundedBuffer {
final Lock lock = new ReentrantLock();//鎖對象
final Condition notFull = lock.newCondition();//寫線程條件
final Condition notEmpty = lock.newCondition();//讀線程條件
final Object[] items = new Object[100];//緩存隊列
int putptr/*寫索引*/, takeptr/*讀索引*/, count/*隊列中存在的數據個數*/;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)//如果隊列滿了
notFull.await();//阻塞寫線程
items[putptr] = x;//賦值
if (++putptr == items.length) putptr = 0;//如果寫索引寫到隊列的最後一個位置了，那麼置為0
++count;//個數++
notEmpty.signal();//喚醒讀線程
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)//如果隊列為空
notEmpty.await();//阻塞讀線程
Object x = items[takeptr];//取值
if (++takeptr == items.length) takeptr = 0;//如果讀索引讀到隊列的最後一個位置了，那麼置為0
--count;//個數--
notFull.signal();//喚醒寫線程
return x;
} finally {
lock.unlock();
}
}
}
這就是多個Condition的強大之處，假設緩存隊列中已經存滿，那麼阻塞的肯定是寫線程，喚醒的肯定是讀線程，相反，阻塞的肯定是讀線程，喚醒的肯定是寫線程，那麼假設只有一個Condition會有什麼效果呢，緩存隊列中已經存滿，這個Lock不知道喚醒的是讀線程還是寫線程了，如果喚醒的是讀線程，皆大歡喜，如果喚醒��是寫線程，那麼線程剛被喚醒，又被阻塞了，這時又去喚醒，這樣就浪費了很多時間。
將上面主線程和子線程交替運行的程序進行擴展，三個線程交替運行，代碼如下：
public class ThreeConditionCommunication {
public static void main(String[] args) {
final Business business = new Business();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
business.sub1(i);
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
business.sub2(i);
}
}
}).start();
for (int i = 0; i < 50; i++) {
business.main(i);
}
}
static class Business{
Lock lock = new ReentrantLock();
Condition main = lock.newCondition();
Condition sub1 = lock.newCondition();
Condition sub2 = lock.newCondition();
int runNum = 1;
public void main(int i){
lock.lock();
try {
while(runNum!=1){
main.await();//主線程等待
}
for (int j = 0; j < 100; j++) {
System.out.println("main is looping of "+j+" in "+i);
}
runNum = 2;
sub1.signal();//喚醒子線程1
} catch (Exception e) {
// TODO: handle exception
} finally{
lock.unlock();
}
}
public void sub1(int i){
lock.lock();
try {
while(runNum!=2){
sub1.await();//子線程1等待
}
for (int j = 0; j < 10; j++) {
System.out.println("sub1 is looping of "+j+" in "+i);
}
runNum = 3;
sub2.signal();//喚醒子線程2
} catch (Exception e) {
// TODO: handle exception
} finally{
lock.unlock();
}
}
public void sub2(int i){
lock.lock();
try {
while(runNum!=3){
sub2.await();//子線程2等待
}
for (int j = 0; j < 20; j++) {
System.out.println("sub2 is looping of "+j+" in "+i);
}
runNum = 1;
main.signal();//喚醒主線程
} catch (Exception e) {
// TODO: handle exception
} finally{
lock.unlock();
}
}
}
}
由此可見，Condition在多線程通信的強大作用，可以大大提高程序效率。