在上篇文章(3.Java多线程总结系列：Java的线程同步实现)中，我们介绍了用synchronized关键字实现线程同步。但在Java中还有一种方式可以实现线程同步，那就是Lock锁。
一.同步锁
我们还是用同步锁来实现存取款的例子：
packagecom.chanshuyi.thread;importjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;public classThreadDemo93 {public static voidmain(String[] args) {
Account account= new Account(2300);newDrawMoneyThread(account).start();newDepositeThread(account).start();
}
}class DepositeThread extendsThread{privateAccount account;publicDepositeThread(Account account){this.account =account;
}
@Overridepublic voidrun() {//每次存200，10次共存2000
for(int i = 0; i < 10; i++){
account.deposit(200, i + 1);//模拟存钱的时间间隔
try{
Thread.sleep((long)Math.random()*5);
}catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}class DrawMoneyThread extendsThread{privateAccount account;publicDrawMoneyThread(Account account){this.account =account;
}
@Overridepublic voidrun() {//每次取100，10次共取1000
for(int i = 0; i < 10; i++){
account.withdraw(100, i + 1);//模拟取钱的时间间隔
try{
Thread.sleep((long)Math.random()*5);
}catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}classAccount{private Lock lock = newReentrantLock();//存钱
public void deposit(double amount, inti){
lock.lock();try{
Thread.sleep((long)Math.random()*10000); //模拟存钱的延迟
this.balance = this.balance +amount;
System.out.println("***第" + i + "次，存入钱:" +amount);
System.out.println("***第" + i + "次，存钱后账户余额:" + this.balance);
}catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}finally{
lock.unlock();
}
}//取钱
public void withdraw(double amount, inti){
lock.lock();try{
Thread.sleep((long)Math.random()*10000); //模拟取钱的延迟
if(this.balance >=amount){this.balance = this.balance -amount;
System.out.println("第" + i + "次，取出钱:" +amount);
System.out.println("第" + i + "次，取钱后账户余额:" + this.balance);
}else{
System.out.println("第" + i + "次，余额不足");
}
}catch(InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}publicAccount(){
}public Account(doublebalance){this.balance =balance;
}private doublebalance;
}
当我们进入需要同步的代码时，我们调用lock.lock()方法获取锁对象。当退出同步代码块时，使用lock.unlock()释放锁对象。下面是其中的一个输出：
第1次，取出钱:100.0第1次，取钱后账户余额:2200.0
***第1次，存入钱:200.0
***第1次，存钱后账户余额:2400.0第2次，取出钱:100.0第2次，取钱后账户余额:2300.0
***第2次，存入钱:200.0
***第2次，存钱后账户余额:2500.0第3次，取出钱:100.0第3次，取钱后账户余额:2400.0
***第3次，存入钱:200.0
***第3次，存钱后账户余额:2600.0第4次，取出钱:100.0第4次，取钱后账户余额:2500.0
***第4次，存入钱:200.0
***第4次，存钱后账户余额:2700.0第5次，取出钱:100.0第5次，取钱后账户余额:2600.0
***第5次，存入钱:200.0
***第5次，存钱后账户余额:2800.0第6次，取出钱:100.0第6次，取钱后账户余额:2700.0第7次，取出钱:100.0第7次，取钱后账户余额:2600.0第8次，取出钱:100.0第8次，取钱后账户余额:2500.0第9次，取出钱:100.0第9次，取钱后账户余额:2400.0
***第6次，存入钱:200.0
***第6次，存钱后账户余额:2600.0
***第7次，存入钱:200.0
***第7次，存钱后账户余额:2800.0第10次，取出钱:100.0第10次，取钱后账户余额:2700.0
***第8次，存入钱:200.0
***第8次，存钱后账户余额:2900.0
***第9次，存入钱:200.0
***第9次，存钱后账户余额:3100.0
***第10次，存入钱:200.0
***第10次，存钱后账户余额:3300.0
上面这个例子只是实现了存款和取款的隔离，使其不能同时进行存取款操作。但是没有考虑到余额不足的情况，所以当我们将初始账户的余额改为0时，其最后的余额就不是准确的数据了。那ReentrantLock锁能使用wait()/notify()进行线程通信么？答案是可以，但是不是使用wait()/notify()，而是使用Condition对象的await()和signal()方法。
二.用Condition进行线程间通信
packagecom.chanshuyi.thread.part3.part36;importjava.util.concurrent.locks.Condition;importjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;/*** 银行存取款 - 使用Lock锁进行线程同步，用Condition进行线程通信
* 实现效果：不会出现余额不足的情况
*@authoryurongchan
**/
public classThreadDemo1 {public static voidmain(String[] args) {
Account account= new Account(0);newDrawMoneyThread(account).start();newDepositeThread(account).start();
}
}class DepositeThread extendsThread{privateAccount account;publicDepositeThread(Account account){this.account =account;
}
@Overridepublic voidrun() {//每次存200，10次共存2000
for(int i = 0; i < 10; i++){
account.deposit(200, i + 1);//模拟存钱的时间间隔
try{
Thread.sleep((long)Math.random()*5);
}catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}class DrawMoneyThread extendsThread{privateAccount account;publicDrawMoneyThread(Account account){this.account =account;
}
@Overridepublic voidrun() {//每次取100，10次共取1000
for(int i = 0; i < 10; i++){
account.withdraw(100, i + 1);//模拟取钱的时间间隔
try{
Thread.sleep((long)Math.random()*5);
}catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}classAccount{private Lock lock = newReentrantLock();private Condition sufficientFunds =lock.newCondition();//存钱
public void deposit(double amount, inti){
System.out.println("***取款进程" + i + "准备存款.");
lock.lock();try{
Thread.sleep((long)Math.random()*10000); //模拟存钱的延迟
this.balance = this.balance +amount;
System.out.println("***存款进程" + i + "存款" +amount);
System.out.println("***存款进程" + i + "存款后账户余额:" + this.balance);
sufficientFunds.signalAll();//每次存入钱就唤醒其他存钱进程，通知其余额可能足够取款了
} catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}finally{
lock.unlock();
}
}//取钱
public void withdraw(double amount, inti){
System.out.println("---取款进程" + i + "准备取款.");
lock.lock();while (this.balance
System.out.println("---取款进程" + i + "准备取款时发现余额不足.放弃对象锁，进入阻塞状态.");
sufficientFunds.await();//余额不足，等待
System.out.println("---取款进程" + i + "被唤醒，重新尝试取款.");
}catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("---账户余额充足.取款进程" + i + "开始取款.");try{
Thread.sleep((long) Math.random() * 10000); //模拟取钱的延迟
this.balance = this.balance -amount;
System.out.println("---取款进程" + i + "成功取款:" +amount);
System.out.println("---取款进程" + i + "成功取款后余额:" + this.balance);
}catch(InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}publicAccount(){
}public Account(doublebalance){this.balance =balance;
}private doublebalance;
}
上面的代码我们故意将账户余额设置为0，虚拟了账户余额不足的情况。之后我们通过lock.newCondition方法创建了一个sufficientFunds的条件，当我们判断得出余额不足的时候，我们调用sufficientFunds.await()方法让该线程放弃条件(Condition)对应的锁对象，让其他存款进程可以往账户中取款。当存款进程成功存款之后，存款进程调用sufficientFunds.signal()方法通知取款进程说：我存钱进去了，你再看看钱够不够。这时候取款进程继续运行，判断余额是否足够，如果不足则继续放弃锁对象并等待，否则就进行取款操作。下面是其中一次运行结果：
---取款进程1准备取款.---取款进程1准备取款时发现余额不足.放弃对象锁，进入阻塞状态.***取款进程1准备存款.***存款进程1存款200.0
***存款进程1存款后账户余额:200.0
---取款进程1被唤醒，重新尝试取款.---账户余额充足.取款进程1开始取款.***取款进程2准备存款.---取款进程1成功取款:100.0
---取款进程1成功取款后余额:100.0
---取款进程2准备取款.***存款进程2存款200.0
***存款进程2存款后账户余额:300.0
---账户余额充足.取款进程2开始取款.***取款进程3准备存款.---取款进程2成功取款:100.0
---取款进程2成功取款后余额:200.0
---取款进程3准备取款.***存款进程3存款200.0
***存款进程3存款后账户余额:400.0
---账户余额充足.取款进程3开始取款.***取款进程4准备存款.---取款进程3成功取款:100.0
---取款进程3成功取款后余额:300.0
---取款进程4准备取款.***存款进程4存款200.0
***存款进程4存款后账户余额:500.0
---账户余额充足.取款进程4开始取款.***取款进程5准备存款.---取款进程4成功取款:100.0
---取款进程4成功取款后余额:400.0
---取款进程5准备取款.***存款进程5存款200.0
***存款进程5存款后账户余额:600.0
---账户余额充足.取款进程5开始取款.***取款进程6准备存款.---取款进程5成功取款:100.0
---取款进程5成功取款后余额:500.0
---取款进程6准备取款.***存款进程6存款200.0
***存款进程6存款后账户余额:700.0
---账户余额充足.取款进程6开始取款.***取款进程7准备存款.---取款进程6成功取款:100.0
---取款进程6成功取款后余额:600.0
---取款进程7准备取款.***存款进程7存款200.0
***存款进程7存款后账户余额:800.0
---账户余额充足.取款进程7开始取款.***取款进程8准备存款.---取款进程7成功取款:100.0
---取款进程7成功取款后余额:700.0
---取款进程8准备取款.***存款进程8存款200.0
***存款进程8存款后账户余额:900.0
---账户余额充足.取款进程8开始取款.***取款进程9准备存款.---取款进程8成功取款:100.0
---取款进程8成功取款后余额:800.0
---取款进程9准备取款.***存款进程9存款200.0
***存款进程9存款后账户余额:1000.0
---账户余额充足.取款进程9开始取款.***取款进程10准备存款.---取款进程9成功取款:100.0
---取款进程9成功取款后余额:900.0
---取款进程10准备取款.***存款进程10存款200.0
***存款进程10存款后账户余额:1100.0
---账户余额充足.取款进程10开始取款.---取款进程10成功取款:100.0
---取款进程10成功取款后余额:1000.0
从上面的运行结果我们可以看出，一开始取款线程1准备取款，但是此时账户余额为0，无法取款，于是取款线程1让出对象锁，并等待。存款线程1因此获得了对象锁，并成功存进200，并唤醒了所有取款线程。此时取款线程1苏醒过来并判断账户余额满足了取款需求，于是取款线程1进行取款操作。
到这里我们学会了如何用synchronized和lock进行线程同步，并且利用其相对应的wait()/notify和Condition进行线程间的通信，以实现更高级的功能。
那既然synchronized能实现的功能，为什么还要有lock锁呢？他们之间究竟有什么异同呢？
三.同步线程的实现原理(共同点)
其实无论通过synchronized方法、synchronized代码块、还是Lock锁，他们的共同点都是传入一个唯一的对象，并以这个唯一的对象作为锁来实现线程同步的。虽然使用synchronized方法进行线程同步时并没有显示地传入一个锁对象，但是实际上它默认锁对象的就是synchronized方法所在类的对象(即例子中的Account对象)
三.使用synchronized的wait()/notify() 和 Lock的Condition进行线程通信有什么区别？(不同点)
使用synchronized和lock都能实现线程的通信，但是synchronized和wait()/notify()方法只能实现两个线程之间的通信，当有更多的线程需要互相通信时，wait()/notify()就无法做到了。而Lock对象能通过newCondition()方法创建出无数的"条件"，通过这些条件，我们就能够成功地实现多线程(N>3)之间的数据通信，对它们进行控制。
比如我需要用线程实现这样的功能：有老大、老二、老三三个人，我们要这3个人进行报数，报数的顺序是这样的，首先是老大报数，报5次；然后是老二报数，报5次；之后是老三报数，报5次；就这样一直报两轮。
我们可以用三个方法分别代表三个人的报数，outputOne()方法代表老大报数，outputTwo()方法代表老二报数，outputThree()方法代表老三报数。接下来就是如果确保他们是按我们需要的顺序进行报数的。这时候如果我们用wait()和notify()方法的话，当老大报完数使用notifyAll()方法唤醒线程，这时候老二和老三都会抢着去报数，这时候我们是无法对其进行准确的顺序控制的。
但Lock锁的newCondition()方法允许有多个条件(Condition)，我们可以创建三个条件，分别代表3个通知，比如：调用condition1.signal()时代表让老大报数，调用condition2.signal()时让老二报数，调用condition3.signal()时让老三报数，这样子就可以精准的控制他们的执行顺序了。实现后的代码如下：
packagecom.chanshuyi.class13;importjava.util.concurrent.locks.Condition;importjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;/*** 用Condition实现多个操作的通信协作
* Condition不同于Object.wait()和Object.notify()的一个方面就是Condition能实现多个操作之间的相互协调通信，而Object.wait()和Object.notify()只能是两个操作之间的协调通信
* 这个实例实现3个线程轮流输出
*@authorchenyr
* @time 2014-12-24 下午06:40:30
* All Rights Reserved.*/
public classCondition3 {public static void main(String[] args)throwsException{final Outputer outputer = newOutputer();new Thread(newRunnable(){public voidrun(){for(int i = 1; i <= 2; i++){try{
outputer.outputOne(i);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();new Thread(newRunnable(){public voidrun(){for(int i = 1; i <= 2; i++){try{
outputer.outputTwo(i);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();new Thread(newRunnable(){public voidrun(){for(int i = 1; i <= 2; i++){try{
outputer.outputThree(i);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
}classOutputer{private int index = 1; //1表示该老大输出，2表示该老二输出，3表示该老三输出final Lock lock = newReentrantLock();final Condition condition1 =lock.newCondition();final Condition condition2 =lock.newCondition();final Condition condition3 =lock.newCondition();//老大的输出
public void outputOne(int i) throwsInterruptedException{
lock.lock();
System.out.println("outputOne-" + i + " has lock.");try{while(index != 1){
System.out.println("outputOne-" + i + " has release the lock and wait.");
condition1.await();
}for(int j = 1; j <= 5; j++){
System.out.println("老大的第" + i + "次,第" + j + "小次");
}
index= 2;
condition2.signal();
}finally{
lock.unlock();
}
}//老二的输出
public void outputTwo(int i)throwsInterruptedException{
lock.lock();
System.out.println("outputTwo-" + i + " has lock.");try{while(index != 2){
System.out.println("outputTwo-" + i + " has release the lock and wait.");
condition2.await();
}for(int j = 1; j <= 5; j++){
System.out.println("老二的第" + i + "次,第" + j + "小次");
}
index= 3;
condition3.signal();
}finally{
lock.unlock();
}
}//老三的输出
public void outputThree(int i)throwsInterruptedException{
lock.lock();
System.out.println("outputThree-" + i + " has lock.");try{while(index != 3){
System.out.println("outputThree-" + i + " has release the lock and Wait.");
condition3.await();
}for(int j = 1; j <= 5; j++){
System.out.println("老三的第" + i + "次,第" + j + "小次");
}
index= 1;
condition1.signal();
}finally{
lock.unlock();
}
}
}
下面是输出的结果：
1 outputOne-1has lock.2 老大的第1次,第1小次3 老大的第1次,第2小次4 老大的第1次,第3小次5 老大的第1次,第4小次6 老大的第1次,第5小次7 outputThree-1has lock.8 outputThree-1has release the lock and Wait.9 outputTwo-1has lock.10 老二的第1次,第1小次11 老二的第1次,第2小次12 老二的第1次,第3小次13 老二的第1次,第4小次14 老二的第1次,第5小次15 outputTwo-2has lock.16 outputTwo-2has release the lock and wait.17 outputOne-2has lock.18 outputOne-2has release the lock and wait.19 老三的第1次,第1小次20 老三的第1次,第2小次21 老三的第1次,第3小次22 老三的第1次,第4小次23 老三的第1次,第5小次24 outputThree-2has lock.25 outputThree-2has release the lock and Wait.26 老大的第2次,第1小次27 老大的第2次,第2小次28 老大的第2次,第3小次29 老大的第2次,第4小次30 老大的第2次,第5小次31 老二的第2次,第1小次32 老二的第2次,第2小次33 老二的第2次,第3小次34 老二的第2次,第4小次35 老二的第2次,第5小次36 老三的第2次,第1小次37 老三的第2次,第2小次38 老三的第2次,第3小次39 老三的第2次,第4小次40 老三的第2次,第5小次
一开始老大报了5次数，之后老大还准备继续报数(第7行)，但是index此时表明应该是老二报数了，所以老大只能时调用condition.await()方法暂时泛起锁(第8行)。之后老二获得了对象锁(第9行)进行了报数……
从线程同步上来看，无论synchronized还是Lock，他们的底层都是通过传入唯一的锁对象来实现线程同步的。
从线程通信来看，synchronized的线程只能实现两个线程之间的通信，但是Condition却可以实现更多线程之间的通信。
【MARK1 本篇的思维导图】
415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
