(删)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();
        }
    }
}

下面是输出的结果:

 1 outputOne-1 has lock.
 2 老大的第1次,第1小次
 3 老大的第1次,第2小次
 4 老大的第1次,第3小次
 5 老大的第1次,第4小次
 6 老大的第1次,第5小次
 7 outputThree-1 has lock.
 8 outputThree-1 has release the lock and Wait.
 9 outputTwo-1 has lock.
10 老二的第1次,第1小次
11 老二的第1次,第2小次
12 老二的第1次,第3小次
13 老二的第1次,第4小次
14 老二的第1次,第5小次
15 outputTwo-2 has lock.
16 outputTwo-2 has release the lock and wait.
17 outputOne-2 has lock.
18 outputOne-2 has release the lock and wait.
19 老三的第1次,第1小次
20 老三的第1次,第2小次
21 老三的第1次,第3小次
22 老三的第1次,第4小次
23 老三的第1次,第5小次
24 outputThree-2 has lock.
25 outputThree-2 has 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 本篇的思维导图】

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏数据结构与算法

洛谷P2792 [JSOI2008]小店购物(最小树形图)

一开始的思路:新建一个虚点向每个点连边,再加上题面中给出的边,边权均为大小*需要购买的数量

10210
来自专栏WindCoder

java基于SSM的Quartz计划任务配置

想找下Quartz的资料看下,某度,随之眼瞎,你们copy就算了,就不能用心点么,连个代码高亮都不忍心加,实在没心情看下去,但还是要忍一下,待我整理完整,再也不...

37510
来自专栏小怪聊职场

爬虫课堂(二十七)|使用scrapy-redis框架实现分布式爬虫(2)源码分析

66560
来自专栏Java成神之路

Java微信开发_Exception_01_The type org.xmlpull.v1.XmlPullParser cannot be resolved. It is indirectly ref

这个异常是在做微信开发时出现的,在引入了XStream的jar包之后,还是出现了如下错误信息:

11730
来自专栏数据结构与算法

BZOJ1269: [AHOI2006]文本编辑器editor

Descriptio 这些日子,可可不和卡卡一起玩了,原来可可正废寝忘食的想做一个简单而高效的文本编辑器。你能帮助他吗? 为了明确任务目标,可可对“文本编辑器...

30570
来自专栏高性能服务器开发

【java多线程】多线程并发同步问题及解决方法

一、线程并发同步概念 线程同步其核心就在于一个“同”。所谓“同”就是协同、协助、配合,“同步”就是协同步调昨,也就是按照预定的先后顺序进行运行,即“你先,我等,...

53380
来自专栏Spark学习技巧

textFile构建RDD的分区及compute计算策略

1,textFile A),第一点,就是输入格式,key,value类型及并行度的意义。 def textFile( path: String, mi...

27570
来自专栏图像识别与深度学习

蓝牙项目开发心得

36190
来自专栏JavaWeb

Mybatis源码-XXXmapper.xml中的resultMap标签解析过程

19330
来自专栏微信公众号:Java团长

使用Java语言从零开始创建区块链

目前网络上关于区块链入门、科普的文章不少,本文就不再赘述区块链的基本概念了,如果对区块链不是很了解的话,可以看一下我之前收集的一些入门学习资源:http://b...

34630

扫码关注云+社区

领取腾讯云代金券