咸鱼的自我修养 - Java中的同步锁（类锁、对象锁、方法锁）

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量1.3k 收藏 9
点赞数 3
分类专栏： 【咸鱼的自我修养】系列 文章标签： java 多线程
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/wk14444/article/details/108001296
版权

今天，又是自我救赎的一天。。。

顶着副热带高压导致的高温上下班，在公司忙了一星期，也没学到多少东西，还是得靠自己下功夫修炼啊，早日把功夫练到化境，天下公司，大可去得！

在这里插入图片描述

好了好了，吐槽完毕，回归正题。

这次跟大家讨论的是Java中的同步锁。

特别提醒一下，如果有读者不想看太多的文字，可以直接拷贝下面的代码到自己的编译器里，运行一下，差不多就能看懂了。

同步锁

我们先看看同步锁的概念：

同步锁是为了保证每个线程都能正常执行原子不可更改操作，同步监听对象/同步锁/同步监听器/互斥锁的一个标记锁.
每个Java对象都有且只有一个同步锁,在任何时刻,最多只允许一个线程拥有这把锁,当消费者线程试图执行以带有synchronized(this)标记的代码块时,消费者线程必需先获得this关键字引用的Stack对象的锁.

emmmm，说人话！！！

其实同步锁就是为了解决多线程环境下的数据共享、同步的线程安全问题的。

假设有下面的一个场景：

某一天，你（线程共享对象）正在苦逼的工作，然后你的两个领导（线程）同时来找你，让你帮他们干活。

在这里插入图片描述
那么，你要怎么办呢？先去项目经理那干一半，再跑到技术总监那干一半，然后就这样来回跑着把活干完？

不合适。

为此，项目经理和技术总监开始互相撕逼（卧槽，你的身价可以啊，能让两个Leader为你做到这一步），

接下来好戏开始了：

最后项目经理赢了（拿到同步锁），

大笑着把你带到他的办公室，开始干活，等你帮项目经理干完活（线程执行完毕），

项目经理笑眯眯的对技术总监说：“现在轮到你了”（释放同步锁），

你又去技术总监的办公室接着干活（另一个线程拿到了同步锁），

终于，你把所有的活都干完了，技术总监说，小王啊，你去忙你的吧（没事赶紧爬。。。释放了同步锁）

你很无奈的回到自己的工位上，继续喝着咖啡加着班（CPU空闲）。

这充满着血与泪的小故事，应该能帮你理解同步锁的作用。

同步锁的作用大概了解了，下面谈谈同步锁的分类。

在Java中，同步锁大致分为两类：

  • 对象锁
  • 类锁

那我们常听到的方法锁是什么呢？方法锁在概念上是属于对象锁的。

对象锁

类声明后，我们可以 new 出来很多的实例对象。这时候，每个实例对象在 JVM 中都有自己的引用地址和堆内存空间，这时候，我们就认为这些实例都是独立的个体，很显然，在实例对象上加的锁和其他的实例对象是没有关系的，互不影响。

在Java中，通过synchronized关键字实现对象锁有3种方式：

  1. 非静态变量
  2. 非静态方法
  3. this关键字

还是以上面的场景为例，我用代码实现了这3种方式的对象锁。

环境

先说明一下我的环境，因为用了lambda表达式简化匿名内部类，所以要求JDK是1.8及以上，我用的8u261。

同时，为了方便观察线程执行的过程，最好在输出的结果上面加上时间戳，如果使用常规的System.out.println()打印结果，需要自己显式的加入时间戳，可以通过Java中提供的Date、Calendar等日期相关类或者System.currentTimeMillis()实现，但我为了方便，引入了slf4j和lombok进行日志打印。

maven坐标如下：

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.18</version>
    <scope>provided</scope>
</dependency>

<!-- slf4j是接口层依赖，logback是slf4j的实现 -->

<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
<!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-classic -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

Worker类：苦逼工作的你

package cn.skywalker.test.thread.lock;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

/** 
 * @author SkyWalker
 * @date 2020 - 08 - 14 - 9:44
 */
@Slf4j
public class Worker {
    /**
     * 线程睡眠时间，单位为秒
     */
    public static final Integer SLEEP_TIME = 1;

    /**
     * 非静态变量作为锁对象
     */
    public final Object OBJECT_LOCK = new Object();
 
    /**
     * 对象锁之非静态变量
     */
    public void workObjectLock() {
        synchronized (OBJECT_LOCK) {
            try {
                String threadName = Thread.currentThread().getName();
                log.info(threadName + "  --->  ready to work");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + "  --->  working...");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + "  --->  work complete");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 对象锁之this
     */
    public void workThisLock() {
        synchronized (this) {
            try {
                String threadName = Thread.currentThread().getName();
                log.info(threadName + "  --->  ready to work");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + "  --->  working...");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + "  --->  work complete");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 对象锁之非静态方法
     */
    public synchronized void workSync() {
        try {
            String threadName = Thread.currentThread().getName();
            log.info(threadName + "  --->  ready to work");
            TimeUnit.SECONDS.sleep(SLEEP_TIME);
            log.info(threadName + "  --->  working...");
            TimeUnit.SECONDS.sleep(SLEEP_TIME);
            log.info(threadName + "  --->  work complete");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    } 
}

ObjectLock类：测试对象锁的类

package cn.skywalker.test.thread.lock;

/**
 * @author SkyWalker
 * @date 2020 - 08 - 14 - 9:58
 */
public class ObjectLock {
    private static Worker worker = new Worker();

    public static void main(String[] args) {
        workObjectLock();
        //workThisLock();
        //workSync();
    }

    private static void workObjectLock() {
        new Thread(() -> {
            worker.workObjectLock();
        }, "jack").start();

        new Thread(() -> {
            //Worker worker = new Worker();
            worker.workObjectLock();
        }, "rose").start();
    }

    private static void workThisLock() {
        new Thread(() -> {
            worker.workThisLock();
        }, "jack").start();

        new Thread(() -> {
            //Worker worker = new Worker();
            worker.workThisLock();
        }, "rose").start();
    }

    private static void workSync() {
        new Thread(() -> {
            worker.workSync();
        }, "jack").start();

        new Thread(() -> {
            //Worker worker = new Worker();
            worker.workSync();
        }, "rose").start();
    }
}

运行结果

main方法中的三个函数随便调用哪一个，最后的结果都应该是：
在这里插入图片描述

可以看到，两个线程 jack 和 rose 的执行是有序的。

类锁

类锁是加在类上的，而类的相关信息是存在 JVM 方法区的，并且整个 JVM 只有一份，方法区又是所有线程共享的，所以类锁是所有线程共享的。该类的所有实例对象也共享这个锁，也就意味着这把锁会影响到每一个实例对象。

在Java中，通过synchronized关键字实现类锁也有3种方式：

  1. 静态变量
  2. 静态方法
  3. Class对象

这次我们的场景如下：

今天是发工资的日子，
但是财务部的人不想让办公室那么拥挤和混乱，
规定一次只能进来一个人领工资。

jack 和 rose 同时到了财务部办公室门口，
两人决定石头剪刀布决胜负。
（这里注意，是两个不同的人）

结果jack 赢了（拿到类锁），

进去领了工资，美滋滋出来了（释放类锁）。

然后rose才进去领工资。

代码实现：

Worker类：jack和rose（和我一样可怜的CRUDer）

package cn.skywalker.test.thread.lock;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

/**
 * @author SkyWalker
 * @date 2020 - 08 - 14 - 9:44
 */
@Slf4j
public class Worker {
    /**
     * 线程睡眠时间，单位为秒
     */
    public static final Integer SLEEP_TIME = 1;
 
    /**
     * 静态变量作为锁对象
     */
    public static final Object CLASS_LOCK = new Object();
 
    /**
     * 类锁之静态变量
     */
    public static void getSalaryObjectLock() {
        synchronized (CLASS_LOCK) {
            try {
                String threadName = Thread.currentThread().getName();
                log.info(threadName + " walked into office ...");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + " got salary...");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + " out of office...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 类锁之Class对象
     */
    public static void getSalaryClassLock() {
        synchronized (Worker.class) {
            try {
                String threadName = Thread.currentThread().getName();
                log.info(threadName + " walked into office ...");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + " got salary...");
                TimeUnit.SECONDS.sleep(SLEEP_TIME);
                log.info(threadName + " out of office...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    /**
     * 类锁之静态方法
     */
    public static synchronized void getSalarySync() {
        try {
            String threadName = Thread.currentThread().getName();
            log.info(threadName + " walked into office ...");
            TimeUnit.SECONDS.sleep(SLEEP_TIME);
            log.info(threadName + " got salary...");
            TimeUnit.SECONDS.sleep(SLEEP_TIME);
            log.info(threadName + " out of office...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ClassLock类：测试类锁的类

package cn.skywalker.test.thread.lock;

/**
 * @author SkyWalker
 * @date 2020 - 08 - 14 - 10:59
 */
public class ClassLock {
    private static Worker worker = new Worker();

    public static void main(String[] args) {
        getSalaryObjectLock();
        //getSalaryClassLock();
        //getSalarySync();
    }

    private static void getSalaryObjectLock() {
        new Thread(() -> {
            worker.getSalaryObjectLock();
        }, "jack").start();

        new Thread(() -> {
            Worker anotherWorker = new Worker();
            anotherWorker.getSalaryObjectLock();
        }, "rose").start();
    }


    private static void getSalaryClassLock() {
        new Thread(() -> {
            worker.getSalaryClassLock();
        }, "jack").start();

        new Thread(() -> {
            Worker anotherWorker = new Worker();
            anotherWorker.getSalaryClassLock();
        }, "rose").start();
    }


    private static void getSalarySync() {
        new Thread(() -> {
            worker.getSalarySync();
        }, "jack").start();

        new Thread(() -> {
            Worker anotherWorker = new Worker();
            anotherWorker.getSalarySync();
        }, "rose").start();
    }
}

运行结果

在这里插入图片描述
也是与我们的预期相符。

结束语

如果通过上面的两个案例没能发现点什么，那我可以说一点文章中没有具体提到的。

在第一个案例的对象锁测试类（ObjectLock类）中，我注释掉了这行代码：
在这里插入图片描述
不妨尝试解开看看运行结果，这个可以帮助你观察到对象锁和类锁的区别与联系。

心想是程
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
9.同步代码块synchronized（对象)
khmff的博客
04-04 3030
1.synchronized(this)中的this锁住的对象是传入new Thread(st)的st对象。this锁住当前对象。 解析：若同步代码块中进入一个new Thread(st)对象，则另一个new Thread(st)线程则进不去同步代码块，除非是传入的是new Thread(st1或其他对象)就不会受影响。 2.synchronized(object obj) 3.synchronized(类.class) public class sellticket implement...
Java synchronized详解
杨宇昌的博客
03-17 9097
java并发 synchronized详解
多线程同步锁synchronized(对象锁与全局锁)总结
qq_40409115的博客
05-05 8970
1.synchronized同步锁的引入/* * 非线程安全 * */ //多个线程共同访问一个对象中的实例变量，则会出现"非线程安全"问题 class MyRunnable1 implements Runnable{ private int num = 10; public void run() { try { if(num &gt; 0) { System.out.p...
多线程（二） 同步 锁对象和条件对象
ying847782627的博客
05-29 2854
什么是线程同步？ 当使用多个线程来访问同一个数据时，非常容易出现线程安全问题(比如多个线程都在操作同一数据导致数据不一致),所以我们用同步机制来解决这些问题。 锁对象  在Java SE5.0引入ReentrantLock类。Lock是Java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定
线程同步 synchronized 同步代码块 同步方法 同步锁
dhxiyzqv45340的博客
01-09 306
一 同步代码块 1.为了解决并发操作可能造成的异常，java的多线程支持引入了同步监视器来解决这个问题，使用同步监视器的通用方法就是同步代码块。其语法如下： synchronized(obj){ //同步代码块 } 其中obj就是同步监视器，它的含义是：线程开始执行同步代码块之前，必须先获得对同步监视器的锁定。任何时刻只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完...
java spring 数据库_java – Spring中的数据库写锁实体
weixin_33597080的博客
02-16 186
为了实现您正在寻找的策略,您需要在父行上触发SELECT FOR UPDATE SQL查询(例如,SELECT * FROM parent WHERE id =？FOR UPDATE.这将获取对所提取的行的锁定SELECT查询.General strategy>开始交易.>使用SELECT FOR UPDATE加载父行.>更新孩子.>拯救孩子.>提交交易.这将保存子项...
Java中synchronized实现对象锁的两种方式及原理解析
五道口
05-17 7481
简介 本文将介绍Java中两种对象锁及其实现方式。分别是同步代码块锁和方法锁。我们将解决上一篇文章《Java中线程安全和线程不安全解析和示例》中提到的线程不安全问题，看看通过synchronized的对象锁，怎样轻松解决该问题。 一.同步代码块锁 案例：通过同步代码块锁，实现两个线程对同一个全局变量count,各自执行1万次count++,验证结果是否等于2万，而不会出现小于2万的情况。 完整代码实现: public class SynchronizeCodeBlockLock implements Run
广联达无驱写锁工具写锁工具.zip
05-09
0802等报错-*-----锁和软件不匹配，解决办法：1赶紧退货，2某宝和咸鱼上有刷锁的（20元左右）3留个纪念得了 4自己开发 5找到原有写锁文件再下下（老锁售后一般都有） 写锁有风险，刷锁需谨慎！！！（出问题概不负责...
库存上锁（文件锁+redis.pdf
12-01
标题中的“库存上锁（文件锁+redis）”是指在分布式系统中，为了保证库存操作的并发一致性，采用的一种复合型锁机制。这种机制结合了文件锁和Redis缓存服务来实现分布式锁的功能。 分布式锁是在多节点环境下，用于...
深蓝挂机锁1.7.rar桌面锁屏幕锁挂机锁
12-10
该软件由"咸鱼哥哥"开发，根据其描述，具备了高度的用户定制性，允许用户根据自己的喜好调整屏幕锁定时的透明度和背景图片，旨在提供一个既实用又个性化的挂机锁体验。 挂机锁是计算机应用中一种常见的安全工具，它...
基于单片机的智能密码锁设计
11-20
内容包括详细设计文档word版，附带开题报告和相关PPT等文档，供大家参考学习。也可在本博客主页找到单片机设计专栏直接查看哦
八位数字密码锁设计资料.rar
01-31
1、资源内容：word版毕业设计lun-wen； 2、学习目标：快速完成相关题目设计； 3、应用场景：课程设计、diy、毕业、参赛； 4、特点：word版，直接可以编辑使用； 5、使用人群：设计参赛人员，学生，教师等。...
java---同步锁实例分析
hl6621的博客
12-07 327
同步锁synchronized是为了解决线程安全提出的，同步锁的作用，在这里我们用一个窗口售票的例子来详细讲解 首先，给出两种可以实现三个窗口完成100票的售卖，方法一就是继承Thread类，方法二就是实现Runnable接口 首先给出Thread类的继承，代码如下： ackage org.westos_07; public class SellTicket extends Thr
同步问题的解决--锁对象Lock
ChineseSoftware的博客
06-30 337
Synchronized和lock区别 一、java.util.concurrent.locks Lock 是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题。代码如下： public class LockTest { public static void main(String[] args) { final Outputter op = new
java加锁与同步方法
热门推荐
long_here的专栏
05-21 3万+
记下来，很重要。 Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而，当一个线程访问object的
java synchronized 同步方法锁
qq_33458228的博客
09-08 196
1.synchronized 对象锁 问题总结 synchronized(对象) 多个锁对象，如果他们的常量相同(常量指针直接执行常量池的情况下)，那么他们就公用一把锁 例子：参数 String a="sds"; String b="sds"; 结论synchronized(a)与synchronized(b)是同步执行，而非异步执行 2.设计之初是想写一个交叉阻塞...
java synchronized对象锁与类锁的区别、同步代码块与同步方法的区别
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
05-19 1万+
终于搞明白synchronized的作用了，献上一篇，如下： java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。 获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内
synchronized对象锁的同步和异步问题
木村的博客
11-03 6819
先上代码:public class MyObject { public synchronized void method1(){ try { System.out.println(Thread.currentThread().getName()); Thread.sleep(4000); } catch (Int
Java内存模型
最新发布
weixin_44267758的博客
07-19 553
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
如何使用java 实现 mysql的行级锁
05-24
在 Java 中使用 MySQL 的行级锁可以通过以下步骤实现： 1. 获取数据库连接 使用 JDBC 驱动程序连接到 MySQL 数据库。可以使用 DriverManager 类的 getConnection() 方法来获取连接对象。 ```java Connection conn = DriverManager.getConnection(url, user, password); ``` 2. 开启事务 为了使用行级锁，需要在事务中执行 SQL 语句。可以使用 Connection 对象的 setAutoCommit() 方法将自动提交关闭，然后使用 beginTransaction() 方法开启一个事务。 ```java conn.setAutoCommit(false); conn.beginTransaction(); ``` 3. 执行 SQL 语句 使用 PreparedStatement 对象执行 SQL 语句，其中包含需要加锁的行的条件。 ```java String sql = "SELECT * FROM table WHERE id = ? FOR UPDATE"; PreparedStatement stmt = conn.prepareStatement(sql); stmt.setInt(1, id); ResultSet rs = stmt.executeQuery(); ``` 其中，FOR UPDATE 是 MySQL 中用于加行级锁的关键字。在执行 SELECT 语句时，MySQL 会为符合条件的行加上排它锁，直到事务提交或回滚为止。 4. 提交事务或回滚事务 如果获取锁后需要修改数据，则可以在获取锁后执行更新操作。在更新完成后，使用 commit() 方法提交事务，或者使用 rollback() 方法回滚事务。 ```java String sql = "UPDATE table SET name = ? WHERE id = ?"; PreparedStatement stmt = conn.prepareStatement(sql); stmt.setString(1, name); stmt.setInt(2, id); stmt.executeUpdate(); conn.commit(); ``` 5. 关闭连接 使用完 Connection 对象后，应该将其关闭。 ```java conn.close(); ``` 需要注意的是，行级锁在执行 SQL 语句时可能会造成死锁。因此，在使用行级锁时需要谨慎考虑锁的粒度和范围，避免出现死锁现象。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值