关于锁的对象

多线程并发下不同同步场景：短信、电话与普通方法的执行顺序
最新推荐文章于 2023-08-10 18:19:09 发布
原创 最新推荐文章于 2023-08-10 18:19:09 发布 · 781 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#锁

锁的对象共有两种：类对象和Class模板对象

1.标准情况下，两个线程、一个对象，先打印发短信还是打电话？发短信
2.发短信方法设置延迟4秒后，两个线程、一个对象，先打印发短信还是打电话？发短信
Synchronized锁的对象是方法的调用者，故两个方法用的是同一把锁，谁先拿到谁执行

package com.itheima.lock8;

import java.util.concurrent.TimeUnit;

public class Test01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendMsg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

//资源类
class Phone{
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发短信");
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"打电话");
    }
}

3.两个线程、一个对象、一个同步方法、一个普通方法，先打印发短信还是hello？hello
因为发短信方法会延迟4秒，hello是普通方法，无锁，不是同步方法，不受锁的影响，不存在抢占资源情况。

package com.itheima.lock8;

import java.util.concurrent.TimeUnit;

public class Test02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sendMsg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.hello();
        },"B").start();
    }
}

//资源类
class Phone2{
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发短信");
    }
    public synchronized void call(){
        
        System.out.println(Thread.currentThread().getName()+"打电话");
    }

    //普通方法
    public void hello(){
        System.out.println(Thread.currentThread().getName()+"=>hello");
    }
}

4.两个线程、两个对象、两个同步方法，先打印发短信还是打电话？打电话
两个对象会存在两把锁，锁不一样，故按照时间顺序来执行

package com.itheima.lock8;

import java.util.concurrent.TimeUnit;

public class Test03 {
    public static void main(String[] args) {
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{
            phone1.sendMsg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

//资源类
class Phone3{
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发短信");
    }
    public synchronized void call(){

        System.out.println(Thread.currentThread().getName()+"打电话");
    }

    //普通方法
    public void hello(){
        System.out.println(Thread.currentThread().getName()+"=>hello");
    }
}

5.两个线程、一个对象、两个静态同步方法，先打印发短信还是打电话？发短信
当同步方法为静态时，锁的是其Class模板，一个类只有一个Class对象

package com.itheima.lock8;

import java.util.concurrent.TimeUnit;

public class Test04 {
    public static void main(String[] args) {
        Phone4 phone4 = new Phone4();
        new Thread(()->{
            phone4.msg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone4.call();
        },"B").start();
    }
}
class Phone4{
    public static synchronized void msg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

6.两个线程、两个对象、两个静态同步方法，先打印发短信还是打电话？发短信
当同步方法为静态时，锁的是其Class模板，一个类只有唯一的一个Class对象

package com.itheima.lock8;

import java.util.concurrent.TimeUnit;

public class Test04 {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{
            phone1.msg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone4{
    public static synchronized void msg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

7.两个线程、一个对象、一个静态同步方法、一个普通同步方法，先打印发短信还是打电话？打电话
静态同步方法锁的是Class类对象，普通同步方法锁的是类对象，因此拥有两把锁，互不冲突

package com.itheima.lock8;

import java.util.concurrent.TimeUnit;

public class Test05 {
    public static void main(String[] args) {
        Phone5 phone = new Phone5();

        new Thread(()->{
            phone.msg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone5{
    public static synchronized void msg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

8.两个线程、两个对象、一个静态同步方法、一个普通同步方法，先打印发短信还是打电话？打电话
拥有两个锁，故先输出没有延时的

package com.itheima.lock8;

import java.util.concurrent.TimeUnit;

public class Test05 {
    public static void main(String[] args) {
        Phone5 phone1 = new Phone5();
        Phone5 phone2 = new Phone5();

        new Thread(()->{
            phone1.msg();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone5{
    public static synchronized void msg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}
详解java 对象锁与类锁
09-07
Java中的对象锁与类锁是多线程编程中非常重要的概念，它们用于控制并发访问，确保数据的一致性和完整性。本文将深入探讨这两种锁的原理、形式及应用场景。 一、对象锁（方法锁） 对象锁，又称为实例锁，是针对特定...
Java对象锁
12-22
　只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。 　每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务可以使用此资源。 　2.synchronized同步块 　2.1...
哪个对象才是锁？
07-13 761
我们都知道当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。这些基础也许大家都知道，但是很多人还是搞不清哪个对象才是锁？如果你能正确回答以下问题，那么才算你彻底搞明白了哪个对象才是锁？ 静态同步方法问题 如下代码是两个静态同步方法 01 Class A{ 02  
ABAP锁、数据库锁
weixin_30576827的博客
02-15 225
ABAP数据锁定... 338 SM12锁查看与维护... 344 通用加锁与解锁函数... 344 ABAP程序锁定... 345 数据库锁... 347 锁的分类和兼容性... 347 并发性与锁的权衡... 348 数据库的事务隔离级别... 348 在JDBC应用程序中设置隔离级别... 349 在应用程序中采用悲观锁和乐观锁... 349 由数据库系统独占锁实现悲...
锁对象
qq_38844728的博客
04-16 673
有两种机制防止代码块受并发访问的干扰。Java语言提供一个synchronized关键字达到这一目的，并且Java SE 5.0引入了ReentrantLook类。synchronized关键字自动提供一个锁以及相关的"条件"，对于大多数需要显式锁的情况，这是很便利的。java.util.concurrent框架为这些基础机制提供了独立的类。 如果使用锁来保护模拟银行转账中的Bank类的tran...
锁是属于对象或类的
溺水三千只取一瓢饮
02-25 878
1、在JVM中，每个对象和类在逻辑上都是和一个监视器相关联的。2、对于对象来说，相关联的监视器保护对象的实例变量(不监视代码)。3、对于类来说，和类相关联的监视器保护类的类变量(不监视代码)。4、如果一个对象没有实例变量，或者一个类没有类变量，则和对象相关联的监视器，或者和类相关联的监视器就什么都不监视。5、监视器是被某个对象或类所拥有的，而线程可以“获取对象的锁”(也就是获取了对
线程安全——关于锁对象的理解
ly0712__的博客
08-10 379
锁对象其实就是锁，锁对象可以是当前Runnable实现类的对象，也可以是Runnable实现类的类，即.class。1、synchronized修饰方法时 锁对象时当前的Runnable实现类的对象2、synchronized修饰静态方法 锁对象是Runnable实现类的类，即.classclass MyThread implements Runnable {}//自定义了Runnable实现类。
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
《深入剖析synchronized锁原理——从Java对象头的角度》 synchronized关键字在Java中扮演着重要的角色，它是Java实现同步的基础，确保了多线程环境下的数据一致性。不同于基于JDK实现的Lock接口（如ReentrantLock）...
ABAP 锁对象与加锁机制
11-21
ABAP 锁对象与加锁机制详解 ABAP 锁对象与加锁机制是 SAP 系统中的一种逻辑锁机制，用于保持数据的一致性和同步访问。锁对象是通过 SE11 创建的，自定义的锁对象必须以 EZ 或者 EY 开头命名。每个锁对象都可以包含...
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例 Java中的锁对象Lock是java.util.concurrent.locks包下的接口，提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。它能以更优雅的方式处理线程...
Java 对象的锁
lsdmx2016的总结
12-19 3600
Java 中每一个对象都有一个锁，当线程访问synchronized 的方法和代码块的时候，会获得这个锁，也可以理解为为这个对象加锁，这个锁在同一时间有且只能被一个线程访问。如果一个线程访问对象锁的时候，锁正在被其他线程访问，那么这个线程就需要等待占用锁的那个线程释放对象锁，陷入阻塞状态。当执行完synchronized方法或者代码块的时候，线程就会释放对象锁。    当线程通过 synchro
Java多线程-新特征-锁(上)
kuyuyingzi的专栏
06-26 163
Java多线程-新特征-锁(上) 在Java5中，专门提供了锁对象，利用锁可以方便的实现资源的封锁，用来控制对竞争资源并发访问的控制，这些内容主要集中在java.util.concurrent.locks 包下面，里面有三个重要的接口Condition、Lock、ReadWriteLock。 Condition: Condition 将 Object 监视器方法（wait、notify...
java并发编程中锁的对象有哪几种？
weixin_45668482的博客
05-30 1802
我们都知道在并发编程学习中锁的概念和使用是必须要学会的，那这个锁到底锁住的是什么呢？它又是如何保证线程之间的并发？ 参考：Java中Synchronized的用法（简单介绍） 锁的分类 java中的锁分为对象锁和类锁 一个类可以有多个对象，所以一个类可以有多个对象锁 一个类只有一个class，所有一个类只能有一个类锁 锁的机制（以synchronized为例） 修饰一个代码块时，该代码块称为同步代码块，同一时刻只能有一个线程进入该同步代码块，锁住的是包含这个代码块的对象。 修饰一个普通方法时，该方法称
Java锁 到底锁的是哪个对象？
fyxxq的专栏
01-12 1万+
一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在java里边就是拿到某个同步对象的锁（一个对象只有一把锁）；如果这个时候同步对象的锁被其他线程拿走了，他（这个线程）就只能等了（线程阻塞在锁池等待队列中）。取到锁后，他就开始执行同步代码(被synchronized修饰的代码）；线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中等待的某个线程就可以拿到锁
8个例子彻底搞懂锁对象
zhaolk的博客
04-05 198
8个例子看懂锁对象到底锁的是什么
Java对象锁的理解
热门推荐
Chujian的博客
07-16 2万+
Java 以前理解Java的锁机制认为：锁的类型分为‘类锁’，’方法锁‘，’对象锁‘。 1.类锁(synchronize(静态对象))：类的所有对象都要竞争锁。 2.方法锁(在方法前加synchronize)： 同一对象同一方法需要竞争锁。 3.对象锁(synchronize(对象))：同一对象代码块竞争锁。 以上都是在学习Java锁的基础理解 其实上面所有的锁，都是“对象锁” 类锁...
java多线程synchronized_Java多线程的同步机制(synchronized)
weixin_30171859的博客
02-12 357
一段synchronized的代码被一个线程执行之前，他要先拿到执行这段代码的权限，在 java里边就是拿到某个同步对象的锁(一个对象只有一把锁)；如果这个时候同步对象的锁被其他线程拿走了，他(这个线程)就只能等了(线程阻塞在锁池 等待队列中)。取到锁后，他就开始执行同步代码(被synchronized修饰的代码)；线程执行完同步代码后马上就把锁还给同步对象，其他在锁池中 等待的某个线程就可以...
java 线程锁对象锁的理解
xmt1139057136的专栏
04-18 1895
锁的等级：方法锁、对象锁、类锁。
change的博客
03-12 1713
（1）基础Java中的每一个对象都可以作为锁。对于同步方法，锁是当前实例对象。对于静态同步方法，锁是当前对象的Class对象。对于同步方法块，锁是Synchonized括号里配置的对象。    当一个线程试图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。那么锁存在哪里呢？锁里面会存储什么信息呢？（2）同步的原理JVM规范规定JVM基于进入和退出 Monitor 对象来实现方法同步...
单选题：关于锁对象的说法错误的是 A. Boolean类型不适合作为锁使用 B. 在异常条件下，保证释放已持有的锁 C. Integer类型不适合作为锁使用 D. 使用相同的方式请求和释放锁，避免死锁
最新发布
09-04
<think> 我们正在分析关于锁对象的说法，判断哪个选项是错误的。选项如下： A. Boolean类型不适合作为锁使用 B. 在异常条件下，保证释放已持有的锁 C. Integer类型不适合作为锁使用 D. 使用相同的方式请求和释放锁，避免死锁 根据引用内容，我们可以逐一分析： 1. **引用[1]**：讨论了Java锁的类型和使用注意事项，包括锁的粒度、死锁避免、性能等。特别提到要选择合适的锁类型，并注意避免死锁。 2. **引用[2]**：关于锁的自动续期机制，确保锁不会在持有者未释放时过期。 3. **引用[3]和[4]**：强调了释放锁时需确保只释放自己的锁，通过检查value值（或使用Lua脚本保证原子性）来避免误删其他线程的锁。 4. **引用[5]**：介绍了在Spring Boot中使用Redis分布式锁的几种方式。 现在分析各选项： - **A. Boolean类型不适合作为锁使用**：在Java中，锁对象可以是任意对象，但通常使用`Object`实例。Boolean类型只有两个值（`TRUE`和`FALSE`），如果多个锁共享同一个Boolean对象（如`Boolean.TRUE`），会导致不同锁之间互相干扰。因此，Boolean不适合作为锁对象，因为它的实例有限，容易造成不同锁之间冲突[^1]。所以这个说法正确。 - **B. 在异常条件下，保证释放已持有的锁**：这是正确的做法。引用[1]提到避免死锁的重要性，而引用[3]和[4]强调即使在异常情况下也要释放锁（例如通过`finally`块），否则可能导致死锁。此外，引用[2]的自动续期机制也是为了确保锁不会因未释放而引发问题。所以这个说法正确。 - **C. Integer类型不适合作为锁使用**：Integer类型和Boolean类似，也存在实例缓存问题（例如`Integer.valueOf(1)`可能返回同一个对象）。如果多个锁使用相同的Integer值（尤其小整数），会导致不同锁之间共享同一个对象，从而造成非预期的同步。因此，Integer也不适合作为锁对象。这个说法正确。 - **D. 使用相同的方式请求和释放锁，避免死锁**：这个说法有缺陷。虽然引用[1]提到要避免死锁，但“使用相同的方式”过于模糊。例如： - 内置锁（synchronized）和显式锁（ReentrantLock）的请求和释放方式不同：synchronized自动释放，而ReentrantLock需要手动`unlock()`。 - 即使同一锁类型，如果请求和释放不对称（如多次lock但只unlock一次），也可能导致死锁。 - 更重要的是，避免死锁需要更多策略，如顺序加锁、超时机制等（引用[1]），而非仅仅“相同方式”。 选项D的错误在于：**“使用相同的方式”并不是避免死锁的关键，关键在于锁的请求和释放必须对称（如lock/unlock成对出现），且需避免循环等待**。单纯“相同方式”无法避免死锁（例如两个线程以相同顺序请求两个不同的锁，但如果其中一个线程异常未释放锁，仍可能死锁）。 因此，**D选项的说法是错误的**，因为它没有准确描述避免死锁的核心要求。 ### 结论 错误选项是**D**，理由如下： - A、B、C均正确：Boolean/Integer因实例共享问题不适合做锁；异常时需保证释放锁。 - D不严谨：避免死锁需要成对释放和有序请求，而非简单“相同方式”。 §§相关问题§§ 1. 为什么Java中不建议使用基本类型的包装类（如Integer、Boolean）作为锁对象？ 2. 在分布式系统中如何实现锁的自动续期机制？[^2] 3. 如何通过锁顺序控制来预防死锁？[^1] 4. Redis分布式锁释放时为什么要使用Lua脚本保证原子性？[^4] </think> ### 锁对象说法错误选项分析 根据提供的引用内容和锁机制原理，我们逐项分析： 1. **A. Boolean类型不适合作为锁使用** **正确** - Boolean只有`true/false`两个值，所有`Boolean.TRUE`是同一个对象 - 多锁场景下不同线程可能共享同一锁对象，导致非预期同步 ```java // 错误示例：多个锁共享Boolean.TRUE synchronized(Boolean.TRUE) { ... } // 线程1 synchronized(Boolean.TRUE) { ... } // 线程2 实际共享同一锁 ``` 2. **B. 在异常条件下，保证释放已持有的锁** **正确（关键实践）** - 引用[1]强调避免死锁需确保锁释放 - 引用[3][4]说明异常时需通过`finally`块或自动续期机制释放锁[^2] ```java ReentrantLock lock = new ReentrantLock(); try { lock.lock(); // 临界区代码（可能抛出异常） } finally { lock.unlock(); // 确保异常时释放 } ``` 3. **C. Integer类型不适合作为锁使用** **正确** - Integer存在缓存池（-128~127返回同一对象） - 数值相同时可能意外共享锁对象 ```java Integer lock1 = 100; // 实际指向缓存同一对象 Integer lock2 = 100; // 非预期锁共享！ ``` 4. **D. 使用相同的方式请求和释放锁，避免死锁** **错误（本题答案）** - **核心缺陷**：相同请求/释放方式**不能保证避免死锁** - 死锁根本原因（引用[1]）： - 循环等待（线程A持锁1等锁2，线程B持锁2等锁1） - 嵌套锁未按固定顺序获取 - **正确方式**（引用[1][5]）： - 锁顺序全局一致性（所有线程按固定顺序加锁） - 超时机制（`tryLock(timeout)`） - 死锁检测（如Redisson的看门狗机制[^5]） ### 总结 **错误选项：D** 最严重错误是认为"相同请求/释放方式可避免死锁"。实际需要更复杂的死锁预防策略： 1. 全局锁顺序控制（如按对象Hash排序加锁）[^1] 2. 尝试锁+超时机制（`lock.tryLock(100ms)`） 3. 使用框架级锁管理（如Redisson的`RFuture<Boolean> tryLockAsync()`[^5]）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值