Java同步、锁机制详解

最新推荐文章于 2023-02-02 10:18:41 发布
最新推荐文章于 2023-02-02 10:18:41 发布
阅读量181 收藏 2
点赞数 3
分类专栏： java基础 # java并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012291690/article/details/118758345
版权

同步、锁

	Java并发编程中，总是会出现多个线程同时对同一条数据的存取，此时可能因为各个线程访问这条数据的次序的顺序不同而造成数据的错误。
	下面通过一个银行转账的例子来说明如何实现多线程同步访问数据。

1.未实现同步的银行转账

首先我们定义银行类Bank

package study_7_15;

import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 大圣啊
 * @date 2021/7/15上午 11:38
 * @description:
 */
public class Bank {

    private final double[] accounts;

    public Bank(int n, double initialBalance) {
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
    }
    public void transfer(int from, int to, double amount) {
        /**
        * @Description 银行转账模拟
        * @Author  大圣啊
        * @Date   2021/7/15 下午 02:19
        * @Param  [from, to, amount]
        * @Return      void
        * @Exception
        */
        if (accounts[from] < amount) {
            return;
        }
        System.out.print(Thread.currentThread());
        accounts[from] -= amount;
        System.out.print("  从" + from + "转了" + String.format("%.2f", amount) + "到" + to);
        accounts[to] += amount;
        System.out.println("  银行总金额:" + String.format("%.2f", getTotalBalance()));
    }

    public double getTotalBalance() {
        /**
        * @Description 获取银行总存款金额
        * @Author  大圣啊
        * @Date   2021/7/15 下午 02:23
        * @Param  []
        * @Return      double
        * @Exception
        */
        double sum = 0;
        for (double a : accounts) {
            sum += a;
        }
        return sum;
    }

    public int size() {
        return accounts.length;
    }
}


接下来我们创建测试类来定义100个银行账户，每个账户初始金额1000，不实现同步。

package study_7_15;

import javax.security.auth.login.AccountException;

/**
 * @author 大圣啊
 * @date 2021/7/15上午 11:34
 * @description:
 */
public class UnsynchBankTest {

    public static final int NACCOUNTS = 100;    //账户总数
    public static final double INITIAL_BANANCE = 1000;  //银行初始余额
    public static final double MAX_ACCOUNT = 1000;  //转账基数
    public static final int DELAY = 10; //进程休眠时间

    public static void main(String[] args) {
        Bank bank = new Bank(NACCOUNTS, INITIAL_BANANCE);
        for (int i = 0; i < NACCOUNTS; i++) {
            int fromAccount = i;
            Runnable r = () -> {
                try {
                    while (true) {
                        int toAccount = (int) (bank.size() * Math.random());
                        double amount = MAX_ACCOUNT * Math.random();    //转账数额
                        bank.transfer(fromAccount, toAccount, amount);  //转账
                        Thread.sleep((long) (DELAY * Math.random()));   //每次转账完成之后休眠进程，计算所有账户总余额
                    }
                } catch (InterruptedException e) {

                }
            };
            Thread thread = new Thread(r);
            thread.start();
        }
    }
}


下面我们来看运行结果，因为是无限循环，所以需要手动停止。

Thread[Thread-73,5,main]  从73转了751.95到69  银行总金额:100000.00
Thread[Thread-93,5,main]  从93转了529.20到66  银行总金额:100000.00
Thread[Thread-52,5,main]Thread[Thread-44,5,main]Thread[Thread-48,5,main]  从44转了510.68到6  银行总额:98562.82
Thread[Thread-54,5,main]  从54转了976.87到58  银行总金额:98562.82
Thread[Thread-60,5,main]  从60转了32.84到89  银行总金额:98562.82
Thread[Thread-80,5,main]  从80转了554.98到56  银行总金额:98562.82
Thread[Thread-41,5,main]  从41转了367.31到62  银行总金额:98562.82
Thread[Thread-53,5,main]  从53转了367.95到59  银行总金额:98562.82

可以看到账户总余额出现的错误，程序运行一段时间，账户总余额总会变多或变少。每当多个进程同时执行时账户总金额都会发生改变，要么变多要么边少，为什么呢？
我们假设某一时刻有两个进程同时执行指令 accounts[to] += amount ，但是问题就在于该指令并不是原子操作。这个指令的处理过程可能如下：
①将 accounts[to] 加载的寄存器中
②将寄存器中的数据 + amount
③将寄存器中的数据写回 accounts[to]
我们假设进程 1 执行完步骤 ①② 之后被剥夺了 CPU 执行权，此时进程 2 被唤醒执行，当进程 2 执行完步骤 ①②③ 之后，已经修改了寄存器中的数据，此时线程 1 倍唤醒执行步骤 ③，
这样执行之后的结果就会发生改变，进程 1 所执行的 accounts[to] += amount 中的变量 amount 是被其他线程修改过的，这就导致了账户总余额发生了错误。

2.通过 ReentrantLock 实现同步

通过ReentrantLock来保护代码块实现同步的基本结构如下：

myLock.lock();  //一个ReentrantLock对象
try{
    //需要保护的代码块
        }
finally{
    myLock.unlock();    //确保执行unLock()方法,即使程序抛出异常
        }

这样的结果可以确保任何时刻只有一个线程进入临界区，一旦一个线程封锁了锁对象，其他任何线程都无法通过lock语句。当其他线程调用lock时，它们会被阻塞，知道第一个线程释放锁对象。
上面的结构中，将unLock()放在finally中是必要的，如果在临界区中抛出了异常，此时锁对象必须被释放，否则其他的线程将被永久阻塞。

了解了ReentrantLock的结构，那么下面就用它来实现对我们代码块的保护。

package study_7_15;

import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 大圣啊
 * @date 2021/7/15上午 11:38
 * @description:
 */
public class Bank {

    private final double[] accounts;
    private Lock bankLock;
    private Condition sufficientFunds;

    public Bank(int n, double initialBalance) {
        /**
         * @Description 银行转账模拟
         * @Author  大圣啊
         * @Date   2021/7/15 下午 02:19
         * @Param  [from, to, amount]
         * @Return      void
         * @Exception
         */
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
        bankLock = new ReentrantLock();
    }


    public void transfer(int from, int to, double amount) throws InterruptedException{
        if (accounts[from] < amount) {
            return;
        }
        bankLock.lock();
        try {
            System.out.print(Thread.currentThread());
            accounts[from] -= amount;
            System.out.print("  从" + from + "转了" + String.format("%.2f", amount) + "到" + to);
            accounts[to] += amount;
            System.out.println("  银行总金额:" + String.format("%.2f", getTotalBalance()));
        }finally {
            bankLock.unlock();

        }
    }

         public double getTotalBalance(){
        /**
         * @Description 获取银行总存款金额
         * @Author  大圣啊
         * @Date   2021/7/15 下午 02:23
         * @Param  []
         * @Return      double
         * @Exception
         */
        bankLock.lock();
        try {
            double sum = 0;
            for (double a : accounts) {
                sum += a;
            }
            return sum;
        }finally {
            bankLock.unlock();
        }
    }


    public int size(){
        return accounts.length;
    }
}

现在我们来看程序的运行结果

Thread[Thread-84,5,main]  从84转了474.38到68  银行总金额:100000.00
Thread[Thread-60,5,main]  从60转了568.12到22  银行总金额:100000.00
Thread[Thread-2,5,main]  从2转了359.58到75  银行总金额:100000.00
Thread[Thread-66,5,main]  从66转了286.62到78  银行总金额:100000.00
Thread[Thread-82,5,main]  从82转了435.10到9  银行总金额:100000.00
Thread[Thread-0,5,main]  从0转了48.10到97  银行总金额:100000.00
Thread[Thread-75,5,main]  从75转了968.66到90  银行总金额:100000.00
Thread[Thread-4,5,main]  从4转了412.57到67  银行总金额:100000.00
Thread[Thread-4,5,main]  从4转了195.58到83  银行总金额:100000.00
Thread[Thread-74,5,main]  从74转了386.82到49  银行总金额:100000.00
Thread[Thread-6,5,main]  从6转了210.35到71  银行总金额:100000.00

此时我们发现账户总余额并不会发生异常，不会上面的程序中出现多个进程同时执行代码块的情况。
但是此时还存在一个问题，就是有些账户会出现负值，当账户余额小于装出金额时我们应该对该线程进行阻塞，直到余额大于等于转出金额时才释放该线程。通过 newCondition 方法获得一个条件对象来控制余额非负。

package study_7_15;

import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 大圣啊
 * @date 2021/7/15上午 11:38
 * @description:
 */
public class Bank {

    private final double[] accounts;
    private Lock bankLock;
    private Condition sufficientFunds;

    public Bank(int n, double initialBalance) {
        /**
         * @Description 银行转账模拟
         * @Author  大圣啊
         * @Date   2021/7/15 下午 02:19
         * @Param  [from, to, amount]
         * @Return      void
         * @Exception
         */
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
        bankLock = new ReentrantLock();
        sufficientFunds = bankLock.newCondition();
    }


    public void transfer(int from, int to, double amount) throws InterruptedException{
        if (accounts[from] < amount) {
            return;
        }
        bankLock.lock();
        try {
            while (accounts[from]<amount){
                sufficientFunds.await();
            }
            System.out.print(Thread.currentThread());
            accounts[from] -= amount;
            System.out.print("  从" + from + "转了" + String.format("%.2f", amount) + "到" + to);
            accounts[to] += amount;
            System.out.println("  银行总金额:" + String.format("%.2f", getTotalBalance()));
            sufficientFunds.signalAll();
        }finally {
            bankLock.unlock();

        }
    }

      public double getTotalBalance(){
        /**
         * @Description 获取银行总存款金额
         * @Author  大圣啊
         * @Date   2021/7/15 下午 02:23
         * @Param  []
         * @Return      double
         * @Exception
         */
        bankLock.lock();
        try {
            double sum = 0;
            for (double a : accounts) {
                sum += a;
            }
            return sum;
        }finally {
            bankLock.unlock();
        }
    }

    public int size(){
        return accounts.length;
    }
}

此时就可以实现不存在账户为负的情况。

3.通过 synchronized 关键字实现同步

上面通过 Lock 和 Condition 对象来完成同步效果，接下来我们通过 synchronized 来实现同步。
如果一个方法用 synchronized 关键字声明，那么对象的锁将保护整个方法。也就是说，要调用该方法，必须获得内部的对象锁。

public synchronized void method (){
	//受保护的代码块
}

这段代码就等价于

publicvoid method(){
this.intrinsicLock.lock();
	try{
	//受保护的代码块
	}
	finally{
		this.intrinsicLock.unLock();
	}
}

我们可以将 Bank 的 transfer 声明为 synchronized，而不是使用一个显式的锁。
下面我们来实现。

package study_7_15;

import java.util.Arrays;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author 大圣啊
 * @date 2021/7/15上午 11:38
 * @description:
 */
public class Bank {

    private final double[] accounts;

    public Bank(int n, double initialBalance) {
        /**
         * @Description 银行转账模拟
         * @Author 大圣啊
         * @Date 2021/7/15 下午 02:19
         * @Param [from, to, amount]
         * @Return void
         * @Exception
         */
        accounts = new double[n];
        Arrays.fill(accounts, initialBalance);
    }


    public synchronized void transfer(int from, int to, double amount) throws InterruptedException {
        if (accounts[from] < amount) {
            return;
        }
        try {
            while (accounts[from] < amount) {
                wait();
            }
            System.out.print(Thread.currentThread());
            accounts[from] -= amount;
            System.out.print("  从" + from + "转了" + String.format("%.2f", amount) + "到" + to);
            accounts[to] += amount;
            System.out.println("  银行总金额:" + String.format("%.2f", getTotalBalance()));
        } finally {
            notify();
        }
    }

    public synchronized double getTotalBalance() {
        /**
         * @Description 获取银行总存款金额
         * @Author 大圣啊
         * @Date 2021/7/15 下午 02:23
         * @Param []
         * @Return double
         * @Exception
         */
        double sum = 0;
        for (double a : accounts) {
            sum += a;
        }
        return sum;
    }

    public int size() {
        return accounts.length;
    }
}

此时我们来看程序运行结果。

Thread[Thread-50,5,main]  从50转了85.71到94  银行总金额:100000.00
Thread[Thread-84,5,main]  从84转了327.18到96  银行总金额:100000.00
Thread[Thread-12,5,main]  从12转了113.29到14  银行总金额:100000.00
Thread[Thread-99,5,main]  从99转了374.85到68  银行总金额:100000.00
Thread[Thread-83,5,main]  从83转了587.17到13  银行总金额:100000.00
Thread[Thread-93,5,main]  从93转了160.65到68  银行总金额:100000.00
Thread[Thread-72,5,main]  从72转了254.90到78  银行总金额:100000.00
Thread[Thread-96,5,main]  从96转了27.94到50  银行总金额:100000.00

可以看到，synchronized 和 显式的锁实现的效果一样，但是显然 synchronized 实现的代码更简洁。


参考书籍：《Java 核心技术卷I 基础知识》
大圣啊丶
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java（day17）同步锁、注解、单例设计模式
qq_44840708的博客
12-22 441
Java（day17）同步锁、注解、单例设计模式
java中的锁与同步
weixin_41688358的博客
09-01 265
锁机制：包括互斥锁、条件变量、读写锁 *互斥锁提供了以排他方式防止数据结构被并发修改的方法。 *读写锁允许多个线程同时读共享数据，而对写操作是互斥的。 *条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。 死锁：多个线程（进程）互相握有对方需要的资源且不放弃自身的资源，进入无限期地阻塞、相互等待的一种状态。 产生死锁的必要条件： 　　1.互斥条件：一个资源每次只能被一个进程使用 　　2.不可剥夺条件：进程已获得资源，在未使用完之前
java线程同步_Java线程：线程的同步与锁
weixin_39630140的博客
02-12 83
Java线程：线程的同步与锁一、同步问题提出线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。例如：两个线程ThreadA、ThreadB都操作同一个对象Foo对象，并修改Foo对象上的数据。public class Foo {private int x = 100;public int getX() {return x;}public int fix(int y) {x = x ...
synchronized同步锁详解
可口可乐的博客
04-07 425
1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如：  　　public synchronized void accessVal(int newVal);  　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能
java锁详解.pdf
12-31
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
Java Volatile关键字同步机制详解
08-19
主要介绍了Java Volatile关键字同步机制详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java线程同步操作实例详解
08-27
主要介绍了java线程同步操作,结合实例形式分析了Java线程同步与锁机制相关原理、操作技巧与注意事项,需要的朋友可以参考下
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
java关键字Synchronized详解
07-04
ava中的关键字synchronized是一种用于实现线程同步的机制。它可以确保在同一时刻，只有一个线程能够访问被synchronized修饰的代码块或方法。这种机制可以有效地避免多线程环境下的数据竞争和不一致问题。 在Java中...
JAVA 同步锁
cimbala的博客
02-02 2568
同一个订单才加同步锁，不同订单可并行。
java 同步锁是什么及synchronized锁的是什么
yezhijing的专栏
12-10 454
java 同步锁是什么及synchronized锁的是什么
Java同步锁
weixin_41923591的博客
05-16 1148
从Java5开始，Java提供了一种功能更强大的线程同步机制——通过显式定义同步锁 对象来实现同步，在这种机制下，同步锁由Lock对象充当。 Lock提供了比synchronized方法和synchronized代码块更广泛的锁定操作，Lock允许 实现更灵活的结构，可以具有差别很大的属性。 Lock是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占 访问，每次只能有一个线程对...
java基础Day17--同步锁+单例设计模式+注解
weixin_52114888的博客
02-14 194
1.同步锁 把有可能出现问题的代码包起来，一次只让一个线程执行。通过sychronized关键字实现同步 当多个对象操作共享数据时，可以使用同步锁解决线程安全问题 1.1 synchronized synchronized(对象){ 需要同步的代码 } 1.2 特点 1、 前提1，同步需要两个或者两个以上的线程 2、 前提2，多个线程间必须使用同一个锁 3、 同步的缺点是会降低程序的执行效率， 为了保证线程安全,必须牺牲性能 4、 可以修饰方法称为同步方法，使用的锁对象是this 5、 可以修饰代码块
面试题总结：volatile的功能
华山栈道的博客
11-01 771
这里写目录标题1.volatile到底做了什么:2.synchronized关键字和volatile关键字比较： 1.volatile到底做了什么: （volatile保证有序性，可见性，不能保证原子性） 禁止了指令重排 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量值，这个新值对其他线程是立即可见的 不保证原子性（线程不安全） 2.synchronized关键字和volatile关键字比较： volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synch
Java并发基础-同步和锁
weixin_30909575的博客
09-02 84
同步和锁 本系列文章主要讲解Java并发相关的内容，包括同步、锁、信号量、阻塞队列、线程池等，整体思维导图如下： 本文主要讲解Java内存模型、同步块、重入锁ReentrantLock和读写锁ReentrantReadWriteLock的应用及源码实现。 我们之所以要用多线程并发，是为了更好地利用服务器资源，使程序的响应速度更好。然而，如果多个线程访问了相同的资源，如同一内存区的变量、数组和对象...
java怎么跨文件,Java-跨多个文件的同步/锁定
weixin_39728221的博客
02-25 65
In my program, I will be storing each "block" of data in a separate file. Multiple threads will both read from and write to various files, and I want to avoid possible problems from not synchronizing ...
Java并发简述（同步注解、发布和溢出、并发容器、工作窃取、锁等）
weixin_43626356的博客
01-13 623
《Java并发编程实战》知识点抽取
Java基础知识十六：同步代码块、同步方法、线程同步、LOCK锁、生产者与消费者
分享Java技术知识，共同成长进步！
07-28 252
7、卖票案例：同步代码块 1、锁多条语句操作共享数据，可以使用同步代码块实现 格式： synchronized(任意对象){ 多条语句操作共享数据的代码 } 2、synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁 优点：解决多线程的数据安全问题 缺点：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率 /*卖票案例 * 需求：某电影院有100张票，三个窗口卖票，设计一个程序模拟该电影院卖票 * 思路： * 1.定.
synchronized锁升级详解
最新发布
08-19
在Java中，synchronized锁的升级是指在不同的场景下，锁的实现方式会有所不同，以提高性能和并发控制的效率。下面是synchronized锁的升级详解： 1. 偏向锁（Biased Locking）：当一个线程访问同步块时，首先会尝试...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大圣啊丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值