synchronized总结

最新推荐文章于 2024-05-13 09:07:05 发布
最新推荐文章于 2024-05-13 09:07:05 发布
阅读量112 收藏
点赞数
文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43912360/article/details/105648128
版权

synchronized总结

synchronized

使用方法

  1. synchronized修饰普通方法，此时锁住的是当前实例对象，进入到同步方法时，需要获取当前实例对象的锁。因此，当多线程作用于两个实例对象时，并不能保证线程安全。

  2. synchronized修饰静态方法，此时锁住的是当前类，进入同步方法时，需要获取当前类的锁。

  3. synchronized修饰代码块，此时锁住的括号中的对象，进入同步代码块时，需要获取给定对象的锁。

代码实现

  1. 作用于同一实例的普通方法
public class SynchronizedMethod {

    private int num = 0;

    synchronized public void add(String type) {

        try {

            if (type.equals("a")) {
                num = 100;
                System.out.println("set A num!");
                Thread.sleep(1000);
            } else {
                num = 200;
                System.out.println("set B num!");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("set number = " + num);
    }

}

@NoArgsConstructor
public class ThreadDemo extends Thread {

    private SynchronizedMethod method;

    private String type;

    private ThisSynchronized thisSynchronized;

    private String thisType;

    public ThreadDemo(SynchronizedMethod method, String type) {
        super();
        this.method = method;
        this.type = type;
    }

    public ThreadDemo(ThisSynchronized thisSynchronized, String thisType) {
        this.thisSynchronized = thisSynchronized;
        this.thisType = thisType;
    }

    
    @Override
    public void run() {
        super.run();

        if (type != null) {
            method.add(type);
        } else if (thisType == "yes"){
            thisSynchronized.serviceMethod();
        } else if (thisType == "no") {
            thisSynchronized.serviceNumber();
        }
    }
}

/**
     * synchronized 修饰方法，调用一个对象
     */
    public static void runSynchronizedOneMethod() {
        SynchronizedMethod method = new SynchronizedMethod();

        ThreadDemo threadA = new ThreadDemo(method,"a");

        ThreadDemo threadB = new ThreadDemo(method, "b");

        threadA.start();
        threadB.start();
    }
public class SynchronizedTest {

    public static void main(String[] args) {

        /**
         *  当synchronized修饰了方法时，同步锁作用于对象，
         *  调用同一个对象，
         *  线程想要执行同步代码需要获取锁，多个线程之间存在竞争关系
         *  所以执行顺序是同步的
         */
        runSynchronizedOneMethod();
	}
}

运行结果：
在这里插入图片描述
由运行结果可知，threadA与threadB是串行运行，多个线程之间竞争的是同一个实例method的锁

  1. 作用于两个不同实例的普通方法
public static void runSychronizedMayMethod() {

        SynchronizedMethod methodA = new SynchronizedMethod();
        SynchronizedMethod methodB = new SynchronizedMethod();

        ThreadDemo threadA = new ThreadDemo(methodA,"a");

        ThreadDemo threadB = new ThreadDemo(methodB, "b");

        threadA.start();
        threadB.start();
    }

运行结果：
在这里插入图片描述
由运行结果可知，应为两个线程之间竞争的是不同实例的锁，所以两个线程是并行的，不存在竞争关系。

  1. 作用于静态方法
public static void runSychronizedStaticMethod() {

        ThreadStaticDemo threadA = new ThreadStaticDemo("A");
        threadA.setName("threadA");

        ThreadStaticDemo threadB = new ThreadStaticDemo("B");
        threadB.setName("threadB");

        threadA.start();
        threadB.start();
    }

public class ThreadStaticDemo extends Thread {
    private String type;

    public ThreadStaticDemo(String type) {
        this.type = type;
    }

    @Override
    public void run() {
        super.run();

        if (type == "A") {
            ThisSynchronized.staticServiceMethodA();
        }
        if (type == "B"){
            ThisSynchronized.staticServiceMethodB();

        }
        if (type == "classA") {
            ThisSynchronized.classServiceMethodA();
        }
        if (type == "classB") {
            ThisSynchronized.classServiceMethodB();
        }
    }
}

synchronized public static void staticServiceMethodA() {
        try {
            System.out.println(" staticServiceMethodA 当前线程名称：" + Thread.currentThread().getName() + "进入同步代码块时间：" + System.currentTimeMillis());

            Thread.sleep(1000);

            System.out.println("staticServiceMethodA 当前线程名称：" + Thread.currentThread().getName() + "离开同步代码块时间：" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public static void staticServiceMethodB() {
        try {
            System.out.println(" staticServiceMethodB 当前线程名称：" + Thread.currentThread().getName() + "进入同步代码块时间：" + System.currentTimeMillis());

            Thread.sleep(1000);

            System.out.println("staticServiceMethodB 当前线程名称：" + Thread.currentThread().getName() + "离开同步代码块时间：" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

运行结果：
在这里插入图片描述
由运行结果可知，由于staticServiceMethodA和staticServiceMethodB两个静态方法被synchronized修饰，两个线程竞争同一个类的锁，所以两个为串行状态。

  1. 作用于代码块
public static void runSychronizedThisMethod() {

        ThisSynchronized thisSynchronized = new ThisSynchronized();

        ThreadDemo threadA = new ThreadDemo(thisSynchronized, "yes");
        ThreadDemo threadB = new ThreadDemo(thisSynchronized, "yes");

        threadA.start();
        threadB.start();
    }
@NoArgsConstructor
public class ThreadDemo extends Thread {

    private SynchronizedMethod method;

    private String type;

    private ThisSynchronized thisSynchronized;

    private String thisType;

    public ThreadDemo(SynchronizedMethod method, String type) {
        super();
        this.method = method;
        this.type = type;
    }

    public ThreadDemo(ThisSynchronized thisSynchronized, String thisType) {
        this.thisSynchronized = thisSynchronized;
        this.thisType = thisType;
    }


    @Override
    public void run() {
        super.run();

        if (type != null) {
            method.add(type);
        } else if (thisType == "yes"){
            thisSynchronized.serviceMethod();
        } else if (thisType == "no") {
            thisSynchronized.serviceNumber();
        }
    }
}

public void serviceMethod() {

        try {

            synchronized (this) {
                System.out.println("start = " + System.currentTimeMillis());

                Thread.sleep(1000);

                System.out.println("end = " + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

运行结果：
在这里插入图片描述
因为两个线程竞争的为同一个对象的锁，所以线程的运行结果为串行状态

原理

jvm基于进入和退出Monitor对象来实现方法同步和代码块的同步。代码块的同步是使用monitorenter和monitorexit指令实现的，同步方法的也是通过这两个指令实现的同步，只是在修饰方法是使用ACC_SYNCHRONIZED来代替了。

monitorenter指令是在编译后插入到同步代码开始的位置，而monitorexit是插入在方法结束活异常的位置，JVM保证这两个命令必须是配对的。每一个对象都有一个monitor与之关联，当monitor被持有后，该对象就处于锁定状态。

参考java 偏向锁、轻量级锁及重量级锁synchronized原理
Synchronize 关键字原理
Synchronize 反编译码分析

weixin_43912360
关注
synchronized 总结
batman
02-26 798
文章目录Monitor 原理synchronized 原理 Monitor 原理 每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针。 Monitor 结构如下: 刚开始 Monitor 中 Owner 为 null 当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monito.
Synchronized总结
1024
03-27 116
尝试获取对象锁，若能够获得锁则继续下一步，否则线程进入阻塞队列 执行synchronized保护的代码块 释放锁（若需要重入则进行相应操作。详细请看本人博客《理解Synchronized（4）》） 对实例方法synchronized保护的是this,对类方法保护的是class对象 synchronized类方法和实例方法保护的对象不同，不同线程可同时访问synchronized类方法和实例...
java synchronized总结
yecong111的专栏
05-29 651
一句话总结： 每个类，每个对象都有一个锁，当在方法或者代码块中添加了synchronized关键字时，要访问这个方法或者这个代码块时就需要获取对应的锁，没有添加synchronized则不受影响。 举例说明： 1、举例的类 package com.sync; public class TestSync {         private Object lock = ne
总结synchronized
m0_66714418的博客
08-10 853
互斥性：synchronized保证了同一时刻只有一个线程可以执行被synchronized修饰的代码块或方法。当一个线程进入synchronized代码块或方法时，其他线程必须等待，直到该线程执行完毕并释放锁。可重入性：同一个线程可以多次获得同一个对象的锁。如果一个线程已经获取了对象的锁，在持有锁的情况下再次进入由synchronized修饰的代码块或方法，不会产生死锁，而是允许继续访问。保证可见性：synchronized不仅保证了线程的互斥执行，还保证了共享变量的可见性。
java的synchronized总结
不积跬步无以至千里
12-31 512
synchronized分为同步方法和同步块 public synchronized void A {   //A区域 } public synchronized void B {   //B区域 } public void C {   synchronized(this) {     //C区域   } } public void D {   synchronized(
【多线程进阶】synchronized的总结
热门推荐
书生-w的博客
04-03 2万+
如果某一个资源被多个线程共享，为了避免因为资源抢占导致资源数据错乱，我们需要对线程进行同步，那么synchronized就是实现线程同步的关键字，可以说在并发控制中是必不可少的部分，今天就来看一下synchronized的使用和底层原理。
Java 关键字 synchronized 总结
GuuInBelieve的博客
12-10 295
同一进程的多个线程共享同一片存储空间，因此当多个线程同时访问同一个数据时，会造成访问冲突。
【Java之多线程】synchronized工作原理总结_java synchronized 总结(1)
2401_84301227的博客
05-13 319
锁升级（锁膨胀）的过程完全是内部自适应完成的，即根据不同的情况（即锁冲突的高或低状态）来升级或降级成对应的状态，不需要用户或者程序员去干预，因此使用起来会比较方便。2.注意，在有些JVM版本上是可以同时实现降级和升级的自适应的，但在有些JVM上只能实现升级的自适应。
【Java之多线程】synchronized工作原理总结_java synchronized 总结
2401_84301315的博客
05-13 758
锁升级（锁膨胀）的过程完全是内部自适应完成的，即根据不同的情况（即锁冲突的高或低状态）来升级或降级成对应的状态，不需要用户或者程序员去干预，因此使用起来会比较方便。2.注意，在有些JVM版本上是可以同时实现降级和升级的自适应的，但在有些JVM上只能实现升级的自适应。
synchronized锁原理分析（一、从Java对象头看synchronized锁的状态）
12-21
总结来说，synchronized的锁机制涉及到对Java对象头的修改，尤其是MarkWord字段。根据锁的状态，MarkWord会存储不同的标记，从而实现锁的管理。无论是轻量级锁还是重量级锁，其背后都是通过对对象头的操作来完成的。...
Synchronized_锁升级知识点总结
11-17
Java作为一种广泛使用的编程语言，其提供了内置的同步机制来实现锁的功能，其中"Synchronized"关键字是最为常用的方式之一。在Java高并发编程领域，理解Synchronized锁的升级机制是非常重要的。 首先需要知道的是，...
Synchronized 和 Lock 的区别和使用场景
01-20
总结来说，`synchronized`和Lock各有优势，前者使用简单，适用于大多数情况，而后者提供了更高级的功能，适合需要精细控制的并发编程。选择哪种锁机制应根据具体需求和性能考虑。在实际开发中，合理地使用锁机制可以...
Synchronized原理总结
qq_44027353的博客
04-14 524
MonitorSynchronized的实现是基于Monitor的，而Monitor是基于管程的MESA模型，ObjectMonitor数据结构，三个队列，等待唤醒机制基于Object对象中的方法对象的内存布局锁的状态信息是标记在对象头的Mark Word中的。一个对象由对象头、实例数据、对齐填充三部分组成。对象头由Mark Word、Klass point、数组长度组成。无锁状态下Mark Word存储的是对象的hash值、gc分代年龄、偏向锁标识位0、锁标识01。
基于Matlab面板版的卡尔曼小球运动跟踪[Matlab面板版].zip
10-16
大模型实战教程
Day01(1).py
10-16
Day01(1).py
面试-PHP高频面试题整理-面试题合集.zip
10-16
面试_PHP高频面试题整理_面试题合集
(最新整理)中国企业OFDI微观数据2005-2022年
最新发布
10-16
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/142994315 2、代码特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理
毕业设计论文SpringBoot+Vue茶叶销售系统.docx
10-16
毕业设计论文
Java synchronized关键字深度解析
总结来说，`synchronized`关键字在Java中扮演着至关重要的角色，为多线程编程提供了一种基本的同步机制，确保了并发执行时的数据安全。正确理解和使用`synchronized`，可以帮助开发者有效地处理线程同步问题，构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值