带着问题理解Synchronized

已于 2024-02-01 11:39:50 修改
阅读量1.7k 收藏 37
点赞数 43
分类专栏： 带着问题学习多线程 文章标签： java 开发语言
于 2024-01-31 22:07:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41917877/article/details/135962666
版权
本文详细解释了Synchronized的作用机制，包括对象锁和类锁的区别，以及其在锁的获取、释放、异常处理和性能上的特性。同时讨论了Synchronized的缺陷，如效率低和缺乏灵活性，以及JavaLock如何弥补这些缺陷。文中还涉及Synchronized与Lock的对比，以及使用Synchronized时的注意事项和性能优化策略。
摘要由CSDN通过智能技术生成

目录

Synchronized可以作用在哪里? 分别通过对象锁和类锁进行举例

在应用Sychronized关键字时需要把握如下注意点：

  • 一把锁只能同时被一个线程获取，没有获得锁的线程只能等待；
  • 每个实例都对应有自己的一把锁(this),不同实例之间互不影响；例外：锁对象是*.class以及synchronized修饰的是static方法的时候，所有对象公用同一把锁
  • synchronized修饰的方法，无论方法正常执行完毕还是抛出异常，都会释放锁

对象锁

包括方法锁(默认锁对象为this,当前实例对象)和同步代码块锁(自己指定锁对象)

代码块形式：手动指定锁定对象，也可是是this,也可以是自定义的锁

同步代码块形式——锁为this,两个线程使用的锁是一样的,线程1必须要等到线程0释放了该锁后，才能执行

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance = new SynchronizedObjectLock();

    @Override
    public void run() {
        // 同步代码块形式——锁为this,两个线程使用的锁是一样的,线程1必须要等到线程0释放了该锁后，才能执行
        synchronized (this) {
            System.out.println("我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
    }
}

输出：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance = new SynchronizedObjectLock();
    // 创建2把锁
    Object block1 = new Object();
    Object block2 = new Object();

    @Override
    public void run() {
        // 这个代码块使用的是第一把锁，当他释放后，后面的代码块由于使用的是第二把锁，因此可以马上执行
        synchronized (block1) {
            System.out.println("block1锁,我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("block1锁,"+Thread.currentThread().getName() + "结束");
        }

        synchronized (block2) {
            System.out.println("block2锁,我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("block2锁,"+Thread.currentThread().getName() + "结束");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
    }
}

输出：

block1锁,我是线程Thread-0
block1锁,Thread-0结束
block2锁,我是线程Thread-0　　// 可以看到当第一个线程在执行完第一段同步代码块之后，第二个同步代码块可以马上得到执行，因为他们使用的锁不是同一把
block1锁,我是线程Thread-1
block2锁,Thread-0结束
block1锁,Thread-1结束
block2锁,我是线程Thread-1
block2锁,Thread-1结束

方法锁形式：synchronized修饰普通方法，锁对象默认为this

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance = new SynchronizedObjectLock();

    @Override
    public void run() {
        method();
    }

    public synchronized void method() {
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();
        t2.start();
    }
}

输出：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

类锁

指synchronize修饰静态的方法或指定锁对象为Class对象

synchronize修饰静态方法

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instance2 = new SynchronizedObjectLock();

    @Override
    public void run() {
        method();
    }

    // synchronized用在普通方法上，默认的锁就是this，当前实例
    public synchronized void method() {
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }

    public static void main(String[] args) {
        // t1和t2对应的this是两个不同的实例，所以代码不会串行
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }
}

输出：

我是线程Thread-0
我是线程Thread-1
Thread-1结束
Thread-0结束
public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instance2 = new SynchronizedObjectLock();

    @Override
    public void run() {
        method();
    }

    // synchronized用在静态方法上，默认的锁就是当前所在的Class类，所以无论是哪个线程访问它，需要的锁都只有一把
    public static synchronized void method() {
        System.out.println("我是线程" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "结束");
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }
}

输出：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

synchronized指定锁对象为Class对象

public class SynchronizedObjectLock implements Runnable {
    static SynchronizedObjectLock instance1 = new SynchronizedObjectLock();
    static SynchronizedObjectLock instance2 = new SynchronizedObjectLock();

    @Override
    public void run() {
        // 所有线程需要的锁都是同一把
        synchronized(SynchronizedObjectLock.class){
            System.out.println("我是线程" + Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束");
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(instance1);
        Thread t2 = new Thread(instance2);
        t1.start();
        t2.start();
    }
}

输出：

我是线程Thread-0
Thread-0结束
我是线程Thread-1
Thread-1结束

Synchronized本质上是通过什么保证线程安全的? 分三个方面回答：加锁和释放锁的原理，可重入原理，保证可见性原理

详见Synchronized原理分析：https://pdai.tech/md/java/thread/java-thread-x-key-synchronized.html

Synchronized有什么样的缺陷? Java Lock是怎么弥补这些缺陷的

synchronized的缺陷

  • 效率低：锁的释放情况少，只有代码执行完毕或者异常结束才会释放锁；试图获取锁的时候不能设定超时，不能中断一个正在使用锁的线程，相对而言，Lock可以中断和设置超时

  • 不够灵活：加锁和释放的时机单一，每个锁仅有一个单一的条件(某个对象)，相对而言，读写锁更加灵活

  • 无法知道是否成功获得锁，相对而言，Lock可以拿到状态，如果成功获取锁，....，如果获取失败，.....

Lock解决相应问题

  • lock(): 加锁
  • unlock(): 解锁
  • tryLock(): 尝试获取锁，返回一个boolean值
  • tryLock(long,TimeUtil): 尝试获取锁，可以设置超时

Synchronized加锁只与一个条件(是否获取锁)相关联，不灵活，后来Condition与Lock的结合解决了这个问题。

多线程竞争一个锁时，其余未得到锁的线程只能不停的尝试获得锁，而不能中断。高并发的情况下会导致性能下降。ReentrantLock的lockInterruptibly()方法可以优先考虑响应中断。 一个线程等待时间过长，它可以中断自己，然后ReentrantLock响应这个中断，不再让这个线程继续等待。有了这个机制，使用ReentrantLock时就不会像synchronized那样产生死锁了。

Synchronized和Lock的对比，和选择?

synchronized用于方法和代码块,不指定锁表示this，也可以指定对象;

Lock只能使用在方法内显示指定lock unlock，并且需要手动释放锁，一般在finally中释放锁，防止发生死锁；
synchronized无需手动释放锁，Lock需要手动释放锁；
synchronized不可中断，Lock可以通过调用lockInterruptibly中断锁；
synchronized获取不到锁一直阻塞，Lock可以通过tryLock方式尝试获取锁，获取不到锁返回false；

Synchronized在使用时有何注意事项

  • 锁对象不能为空，因为锁的信息都保存在对象头里
  • 作用域不宜过大，影响程序执行的速度，控制范围过大，编写代码也容易出错
  • 避免死锁
  • 在能选择的情况下，既不要用Lock也不要用synchronized关键字，用java.util.concurrent包中的各种各样的类，如果不用该包下的类，在满足业务的情况下，可以使用synchronized关键，因为代码量少，避免出错

Synchronized修饰的方法在抛出异常时,会释放锁吗

会释放锁

多个线程等待同一个Synchronized锁的时候，JVM如何选择下一个获取锁的线程?

一个持有锁的线程，在程序运行结束或者出现异常的时候，就会释放这把锁。这个时候除了刚才已经在等待中的线程之外，其他线程也会来竞争这把锁，而竞争结果是由JVM来操作的，获取最终的结果是不公平的（随机的），有可能是等待时间最长的线程获取这把锁，也有可能是刚生成的线程去获取这把锁

Synchronized使得同时只有一个线程可以执行，性能比较差，有什么提升的方法?

优化使用范围

使用其它锁

imaginationtrouble
关注
专栏目录
深入理解Synchronized
fancy_Coding的博客
04-18 2535
前言 大家好，我是fancy~ Synchronized想必大家在工作中一定有接触过，它算是Java并发场景下实现多线程安全一种比较直接的操作。有人会说它慢，确实。在JDK1.6之前，它有另一个名称叫做：重量级锁。但是从1.6版本起，它就在不断被优化。现如今已经是很成熟的并发安全技术；所以关于Synchronized的考察也常常成为面试官青睐的话题。 本文我们会使用图解的方式解析Synchronized的使用和原理，让我们开始吧~ 对象锁和类锁 什么是Synchronized？Synchronized是J
深入理解synchronized关键字
MuskMelon
02-06 213
概念 是 java 中的一个关键字，作用于对象，多线程并发访问此对象时起到同步互斥的作用，可重入 基本用法 作用在对象 给实例对象加锁 作用在方法 给实例对象加锁 作用在静态方法 给类对象加锁 实现原理 作用在对象上 编译成字节码时会生成2个指令，monitorenter和monitorexist monitorenter标识加锁，monitorexist 标识解锁 加解锁需要一个位置来记录对象的解决锁状态 每个对象有一个对象头，对象头中有2个关键数据 mark word klass pointe
深入理解 synchronized 关键字
程序员cxuan的个人主页
06-02 2636
前言 synchronized 这个关键字的重要性不言而喻，几乎可以说是并发、多线程必须会问到的关键字了。synchronized 会涉及到锁、升级降级操作、锁的撤销、对象头等。所以理解 synchronized 非常重要，本篇文章就带你从 synchronized 的基本用法、再到 synchronized 的深入理解，对象头等，为你揭开 synchronized 的面纱。 浅析 synchronized synchronized 是 Java 并发模块非常重要的关键字，它是 Java 内建的一种同步机制
深度理解Synchronized及底层原理
RichardGeek的博客
09-02 724
深入理解synchronized底层原理
Synchronized Integer问题
小石潭记丶
02-23 973
首先为了方便你看文章的时候复现问题，我给你一份直接拿出来就能跑的代码，希望你有时间的话也把代码拿出来跑一下： public class SynchronizedTest { public static void main(String[] args) { Thread why = new Thread(new TicketConsumer(10), "why"); Thread mx = new Thread(new TicketConsumer(10), "m
java中的synchronized理解
u010980545的专栏
12-12 1763
原文网址：http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html synchronized是java语言的关键字（跟static一样），貌似有的地方翻译成同步锁（阻止同步执行的），这个名称挺形象的，从他的名字中就能猜出他大致的用法：当用它来修饰一个方法或者代码块的时候，能够保证在同一时刻最多只有一个线层执行synch
关键字: synchronized详解
qq_63353796的博客
06-19 949
在C程序代码中我们可以利用操作系统提供的互斥锁来实现同步块的互斥访问及线程的阻塞及唤醒等工作。在Java中除了提供Lock API外还在语法层面上提供了synchronized关键字来实现互斥同步原语, 本文将对synchronized关键字详细分析。
深入理解Synchronized关键字底层原理及作用(二)
Imobama的博客
07-20 2934
Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现， 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步(没有monitor指令,由ACC_SYNCHRONIZED标识,即同步方法)都是如此。在 Java 语言中，同步用的最多的地方可能是被 synchronized 修饰的同步方法。同...
Java-synchronized深入理解
一小平民
11-11 942
java中synchronized用法 打个比方：一个object就像一个大房子，大门永远打开。房子里有 很多房间（也就是方法）。 这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。 另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东
深入理解synchronized
Double_Name的专栏
04-19 1330
目前在Java中存在两种锁机制：synchronized和Lock，Lock接口及其实现类是JDK5增加的内容，其作者是大名鼎鼎的并发专家Doug Lea。本文并不比较synchronized与Lock孰优孰劣，只是介绍二者的实现原理。    数据同步需要依赖锁，那锁的同步又依赖谁？synchronized给出的答案是在软件层面依赖JVM，而Lock给出的方案是在硬件层面依赖特殊的CPU指令
synchronized底层实现原理与ReentrantLock初步理解
仰望星空
09-15 1301
前言:在慕课网上学习剑指Java面试-Offer直通车时所做的笔记,供本人复习之用,比较难,我也没大懂,只记录大概意思以后有接触了再改,想要详细解说的不建议看这篇博客. 目录 第一章 对象在内存中的布局 第二章 Monitor 2.1 Monitor在字节码中的表示 第三章 锁的优化 3.1 自旋锁与自适应自旋锁 3.1.1 自旋锁 3.1.2 自适应自旋锁 3.2 锁消除 3...
java基础-CAS、synchronized和AQS的理解
sinat_36387539的博客
03-30 664
其中包含了悲观锁、乐观锁区别，公平锁、非公平锁的区别，CAS、synchronized、AQS等并发面试相关问题
synchronized详解
m0_46669446的博客
03-12 1131
对synchronized的了解 synchronized 关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 在 Java 早期版本中，synchronized 属于 重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的 Mutex Lock 来实现的，Java 的线程是映射到操作系统的原生线程之上的。如果要挂起或者唤醒一个线程，都需要操作系统帮忙完成，而操作系统实现线程之间的切换时.
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 796
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1367
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 844
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 241
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 405
函数式接口与回调函数
Java复习24（PTA)
2301_79272475的博客
10-30 407
Java复习24（PTA)：多种排序的book类*
"Java多线程与并发：synchronized关键字详解及应用
本文将对synchronized关键字进行详细分析，带着BAT大厂的面试问题去理解Synchronized，以帮助读者更好地理解这一关键字。 首先，我们将详细介绍synchronized关键字可以作用的范围，并通过具体的对象锁和类锁来举例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值