(删)Java线程同步实现二:Lock锁和Condition

在上篇文章(3.Java多线程总结系列:Java的线程同步实现)中,我们介绍了用synchronized关键字实现线程同步。但在Java中还有一种方式可以实现线程同步,那就是Lock锁。

一.同步锁

我们还是用同步锁来实现存取款的例子:

package com.chanshuyi.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class ThreadDemo93 { public static void main(String[] args) {
Account account = new Account(2300);
new DrawMoneyThread(account).start();
new DepositeThread(account).start();
}
} class DepositeThread extends Thread{ private Account account; public DepositeThread(Account account){
this.account = account;
} @Override
public void run() {
//每次存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 extends Thread{ private Account account; public DrawMoneyThread(Account account){
this.account = account;
} @Override
public void run() {
//每次取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();
}
}
}
} class Account{ private Lock lock = new ReentrantLock(); //存钱
public void deposit(double amount, int 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);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
lock.unlock();
}
} //取钱
public void withdraw(double amount, int i){
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();
}
} public Account(){
} public Account(double balance){
this.balance = balance;
} private double balance;
}

当我们进入需要同步的代码时,我们调用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进行线程间通信

package com.chanshuyi.thread.part3.part36;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; /**
* 银行存取款 - 使用Lock锁进行线程同步,用Condition进行线程通信
* 实现效果:不会出现余额不足的情况
* @author yurongchan
*
*/
public class ThreadDemo1 { public static void main(String[] args) {
Account account = new Account(0);
new DrawMoneyThread(account).start();
new DepositeThread(account).start();
} } class DepositeThread extends Thread{ private Account account; public DepositeThread(Account account){
this.account = account;
} @Override
public void run() {
//每次存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 extends Thread{ private Account account; public DrawMoneyThread(Account account){
this.account = account;
} @Override
public void run() {
//每次取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();
}
}
} } class Account{ private Lock lock = new ReentrantLock();
private Condition sufficientFunds = lock.newCondition(); //存钱
public void deposit(double amount, int i){
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, int i){
System.out.println("---取款进程" + i + "准备取款.");
lock.lock();
while (this.balance < amount) {
try {
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();
}
} public Account(){ } public Account(double balance){
this.balance = balance;
} private double balance;
}

上面的代码我们故意将账户余额设置为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()时让老三报数,这样子就可以精准的控制他们的执行顺序了。实现后的代码如下:

package com.chanshuyi.class13;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; /**
* 用Condition实现多个操作的通信协作
* Condition不同于Object.wait()和Object.notify()的一个方面就是Condition能实现多个操作之间的相互协调通信,而Object.wait()和Object.notify()只能是两个操作之间的协调通信
* 这个实例实现3个线程轮流输出
* @author chenyr
* @time 2014-12-24 下午06:40:30
* All Rights Reserved.
*/
public class Condition3 { public static void main(String[] args)throws Exception{
final Outputer outputer = new Outputer();
new Thread(new Runnable(){
public void run(){
for(int i = 1; i <= 2; i++){
try {
outputer.outputOne(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start(); new Thread(new Runnable(){
public void run(){
for(int i = 1; i <= 2; i++){
try {
outputer.outputTwo(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start(); new Thread(new Runnable(){
public void run(){
for(int i = 1; i <= 2; i++){
try {
outputer.outputThree(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
} class Outputer{
private int index = 1; //1表示该老大输出,2表示该老二输出,3表示该老三输出 final Lock lock = new ReentrantLock();
final Condition condition1 = lock.newCondition();
final Condition condition2 = lock.newCondition();
final Condition condition3 = lock.newCondition(); //老大的输出
public void outputOne(int i) throws InterruptedException{
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)throws InterruptedException{
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)throws InterruptedException{
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();
}
}
}

下面是输出的结果:

 outputOne-1 has lock.
老大的第1次,第1小次
老大的第1次,第2小次
老大的第1次,第3小次
老大的第1次,第4小次
老大的第1次,第5小次
outputThree-1 has lock.
outputThree-1 has release the lock and Wait.
outputTwo-1 has lock.
老二的第1次,第1小次
老二的第1次,第2小次
老二的第1次,第3小次
老二的第1次,第4小次
老二的第1次,第5小次
outputTwo-2 has lock.
outputTwo-2 has release the lock and wait.
outputOne-2 has lock.
outputOne-2 has release the lock and wait.
老三的第1次,第1小次
老三的第1次,第2小次
老三的第1次,第3小次
老三的第1次,第4小次
老三的第1次,第5小次
outputThree-2 has lock.
outputThree-2 has release the lock and Wait.
老大的第2次,第1小次
老大的第2次,第2小次
老大的第2次,第3小次
老大的第2次,第4小次
老大的第2次,第5小次
老二的第2次,第1小次
老二的第2次,第2小次
老二的第2次,第3小次
老二的第2次,第4小次
老二的第2次,第5小次
老三的第2次,第1小次
老三的第2次,第2小次
老三的第2次,第3小次
老三的第2次,第4小次
老三的第2次,第5小次

一开始老大报了5次数,之后老大还准备继续报数(第7行),但是index此时表明应该是老二报数了,所以老大只能时调用condition.await()方法暂时泛起锁(第8行)。之后老二获得了对象锁(第9行)进行了报数……

从线程同步上来看,无论synchronized还是Lock,他们的底层都是通过传入唯一的锁对象来实现线程同步的。

从线程通信来看,synchronized的线程只能实现两个线程之间的通信,但是Condition却可以实现更多线程之间的通信。

【MARK1 本篇的思维导图】

上一篇:[转]ELO等级分体系


下一篇:Java面试系列第2篇-Object类中的方法