终于弄懂了晦涩难懂的条件锁-condition lock

来源：互联网发布：知乎live过期收听购买编辑：程序博客网时间：2024/06/06 16:37

[java] view plain copy
package com.cn.whu;  
  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
public class ThreadConditionLook {  
  
    /** 
     * @param args 
     */  
    //create a user's Account,watch out the "static"  
    private static Account account = new Account();  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        ExecutorService executor = Executors.newFixedThreadPool(2);  
        executor.execute(new DepositTask());  
        executor.execute(new WithdrawTask());  
        executor.shutdown();  
        System.out.println("Thread 1\t\tThread 2\t\t\t\tBalance");  
    }  
    private static class Account{  
        //create a new lock  
        private static Lock lock = new ReentrantLock();  
        //craete a condition  
        private static Condition newDeposit = lock.newCondition();  
        private int  balance =0;  
        public int getBalance(){  
            return balance;  
        }  
        public void withdraw(int mount){  
            lock.lock();//Acqurie the lock  
            try{  
                while(balance<mount){  
                    System.out.println("\t\t\tWait for a deposit");  
                    newDeposit.await();  
                }  
                balance -=mount;   
                System.out.println("\t\t\tWithdraw "+mount+"\t\t\t\t\t"+getBalance());  
            }catch(InterruptedException e){  
                  
            }finally{  
                lock.unlock();  
            }  
        }  
        public void depsoit(int mount){  
            lock.lock();  
            try{  
                balance+=mount;  
                System.out.println("Deposit "+mount+"\t\t\t\t\t\t\t\t"+getBalance());  
                newDeposit.signalAll();  
            }finally{  
                lock.unlock();  
            }  
        }  
    }  
    //Task for deposit account;  
    private static class DepositTask implements Runnable{  
  
        @Override  
        public void run() {  
            // TODO Auto-generated method stub  
              
            try{  
                while(true){  
                    account.depsoit((int)(Math.random()*10)+1);  
                    Thread.sleep(1000);  
                }  
                  
            }catch(InterruptedException e){  
                  
            }  
              
              
        }  
          
    }  
    //Task for withdraw account  
    private static class WithdrawTask implements Runnable{  
  
        @Override  
        public void run() {  
            // TODO Auto-generated method stub  
            try{  
                while(true){  
                    account.withdraw((int)(Math.random()*10)+1);  
                    Thread.sleep(1000);  
                }  
            }catch(InterruptedException e){  
                  
            }  
        }  
          
    }  
}  

条件锁其实就是一个普通的锁加上了一个条件，如下面两行代码

//create a new lockprivate static Lock lock = new ReentrantLock();

//craete a conditionprivate static Condition newDeposit = lock.newCondition();

，重要的不是表象，是为什么需要这个条件锁，假设你有一个银行账户，密码你和你老婆都知道，你负责存钱，你老婆负责取钱，对存钱和取钱的代码都加了锁，所以是可以同步的。诶，平常存啊取的都挺好的，结果你俩矛盾了，你不去存钱，诶银行发现你老婆仍然可以取，而且透支了，你愿意不？银行愿意不？当然不愿意，也许你马上想到了，诶，我可以在取钱的时候加个条件去判断下，如果够取，那就让这个线程来取钱，否则呢？关键是这个否则呢？把这个线程干掉？不人道吧，让人家自己过N年后来取？这也不人道啊，评啥不是你通知人家老公存钱了，老婆过来看看，看够取不？诶，这个条件锁他就是这个为别人考虑的东西，你老婆一旦发现钱不够取了，他就打电话给你，嘿，小伙子，快点存钱，你说我有事，等会在存，等了很久，你存了一点，好，你在打电话给她，说，你可以去取取看，看过不，不够在打电话给我，够了直接取了就是。

，

我觉你的那个比喻不恰当，特别是这句话：“老婆一旦发现钱不够取了，他就打电话给你，嘿，小伙子，快点存钱，你说我有事，等会在存，等了很久，你存了一点，好，你在打电话给她，说，你可以去取取看，看过不，不够在打电话给我，够了直接取了就是。“
其实就是生产者和消费者问题嘛，取钱的线程发现钱不够就会阻塞，存钱的线程是一直在执行的，一旦存了钱，他便会唤醒取钱的线程。也就是说，他老婆发现钱不够了，并不会打电话给他老公，而是等待她老公去存钱，她老公存了钱，会通知他老婆去取才对。

0 0