synchronized关键字同步原理

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量160 收藏
点赞数
分类专栏： 多线程 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46517733/article/details/131925872
版权
本文通过示例代码详细解释了Java中同步方法和同步代码块的工作原理。同步方法通过ACC_SYNCHRONIZED标志确保线程安全，锁住的是当前类的对象。静态同步方法锁的是类本身。同步代码块则可以指定锁对象，可以通过this或者自定义对象作为锁，不同锁对象的同步代码块可并发执行。
摘要由CSDN通过智能技术生成

1.同步方法

public class Test {
    synchronized public static void testMethod(){}
    public static void main(String[] args) {
        testMethod();
    }
}

// 实现class文件的反汇编
java -c -v *.class

从字节码文件中可以看到同步方法根据flags标志中的ACC_SYNCHRONIZED来判别是否是同步方法。
在这里插入图片描述

1.1 锁对象

同步方法中并不是锁方法而是锁当前类的对象
注：静态同步方法中锁是当前类，而不是对象。

  • 测试：methodA为同步方法，methodB为非同步方法，线程A调用methodA，线程B调用methodB。

TestMethod.java

public class TestMethod {

    synchronized public void methodA() {
        try {
            System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }

    public void methodB() {
        try {
            System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

ThreadA.java

public class ThreadA extends Thread{
    private TestMethod testMethod;

    public ThreadA(TestMethod testMethod) {
        super();
        this.testMethod  = testMethod;
    }
    @Override
    public void run() {
        super.run();
        testMethod.methodA();
    }
}

ThreadB.java

public class ThreadA extends Thread{
    private TestMethod testMethod;

    public ThreadA(TestMethod testMethod) {
        super();
        this.testMethod  = testMethod;
    }
    @Override
    public void run() {
        super.run();
        testMethod.methodA();
    }
}

Test.java

public class Test {
    public static void main(String[] args) {
        TestMethod testMethod = new TestMethod();
        ThreadA threadA = new ThreadA(testMethod);
        threadA.setName("a");
        ThreadB threadB = new ThreadB(testMethod);
        threadB.setName("b");
        threadA.start();
        threadB.start();

    }
}

运行结果：

methodA start ThreadName= a startTime=1690358535034
methodB start ThreadName= b startTime=1690358535034
methodA start ThreadName= a endTime=1690358540035
methodB start ThreadName= b endTime=1690358540035

结论：从结果可以看出，线程A持有TestMethod对象锁，线程B可以调用TestMethod的非同步方法。

  • 测试：methodA和methodB为同步方法，线程A调用methodA，线程B调用methodB。
    TestMethod.java
// 将methodB也修改为同步方法
public class TestMethod {

    synchronized public void methodA() {
        try {
            System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }

    synchronized public void methodB() {
        try {
            System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

结果：

methodA start ThreadName= a startTime=1690359406773
methodA start ThreadName= a endTime=1690359411785
methodB start ThreadName= b startTime=1690359411785
methodB start ThreadName= b endTime=1690359416796

结论：从结果可以看出，线程A先持有TestMethod对象锁，虽然线程B调用的是methodB方法，但是也要等A释放锁之后才能执行。

2.同步代码块

public class Test2 {
    public void myMethod() {
        synchronized (this) {
            int age = 100;
        }
    }

    public static void main(String[] args) {
        Test2 test2 = new Test2();
        test2.myMethod();
    }
}

从字节码文件中可以看到同步代码块根据monitorenter和monitorexit来进行同步处理。
在这里插入图片描述

2.1 锁对象

和同步方法一样，同步代码块synchronized (this)锁的也是对象。
测试：
TestMethod.java

public class TestMethod {

     public void methodA() {
        try {
            synchronized (this) {
                System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }

    public void methodB() {
        try {
            synchronized (this) {
                System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

结果：

methodA start ThreadName= a startTime=1690361223642
methodA start ThreadName= a endTime=1690361228654
methodB start ThreadName= b startTime=1690361228654
methodB start ThreadName= b endTime=1690361233654

注：此时（this）是锁的同一对象，所以methodA和methodB同步执行，如果使用不同对象锁，则互不影响。
测试：
TestMethod.java

public class TestMethod {

	// 也可以使用非对象做为锁。
    private String lock = new String();

     public void methodA() {
        try {
            synchronized (this) {
                System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("methodA start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }

    public void methodB() {
        try {
            synchronized (lock) {
                System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " startTime=" + System.currentTimeMillis());
                Thread.sleep(5000);
                System.out.println("methodB start ThreadName= " + Thread.currentThread().getName() + " endTime=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

结果：

methodA start ThreadName= a startTime=1690361599813
methodB start ThreadName= b startTime=1690361599813
methodA start ThreadName= a endTime=1690361604820
methodB start ThreadName= b endTime=1690361604820

结论：从结果可以看出，虽然methodA和methodB中都存在同步代码块，但是因为锁对象不同，所以两个同步代码块的调用互不影响。

Listen·Rain
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
简单了解Java synchronized关键字同步
08-25
Java synchronized关键字同步详解 Java 中的 synchronized 关键字是用于实现线程同步的重要机制。下面我们将详细介绍 synchronized 关键字的使用方法和原理。 synchronized 关键字的作用 synchronized 关键字可以...
java synchronized关键字原理、自定义一把锁来实现同步等
02-19
本文详细介绍了 `synchronized` 关键字的工作原理以及如何通过自定义锁的方式来实现线程间的同步。`synchronized` 通过 JVM 的监视器机制实现了对共享资源的安全访问，而自定义锁则是利用 CAS 操作和 `Unsafe` 类来...
Java synchronized关键字和Lock接口实现原理
08-25
Java synchronized关键字和Lock接口实现原理 Java 中的 synchronized 关键字和 Lock 接口是两种常用的线程同步机制，它们都可以用来解决并发问题。下面我们将详细介绍 synchronized 关键字和 Lock 接口的实现原理。...
java多线程编程之使用Synchronized关键字同步类方法
09-04
`synchronized`关键字提供了线程同步机制，确保在任何时刻只有一个线程能够执行特定的代码块。 在描述中提到的示例中，将`synchronized`关键字添加到`run()`方法前面，可以使该方法成为同步方法。这意味着当一个...
【Java并发编程】Synchronized关键字实现原理.doc
07-09
Java 并发编程 Synchronized 关键字实现原理 Synchronized 关键字是 Java 并发编程中最基本的同步机制，它可以保证线程安全，包括原子性、可见性和有序性。Synchronized 关键字可以修饰方法或代码块，使得在同一...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 945
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 437
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
jiaowenjie的专栏
08-06 205
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 1275
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 64
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
枚举工具类
qq_43049583的博客
08-04 441
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 516
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1153
C++ string的功能函数实现
Spring事务
最新发布
c1tenj2的博客
08-07 305
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
java selenium 设置代理，允许在其他环境中使用不同的IP访问
huanghm88的专栏
08-05 456
此代码以Chrome浏览器为例，如果你使用其他浏览器，你需要相应地调整代码。另外，你需要下载适用于你的操作系统的Chrome浏览器驱动，并将路径替换为。在Java Selenium中设置代理可以使用。替换为其他环境中要访问的IP地址。替换为实际的代理IP和端口，并将。
在java java.util.Date 已知逝去时间怎么求年月日
huanghm88的专栏
08-05 307
这样，你就可以得到逝去时间的年月日。需要注意的是，这只是一个简单的方法，不考虑闰年等情况。如果你需要更准确的结果，可以使用其他时间处理库，如Joda-Time或java.time包。
Spring-包扫描
Promise_J_Z
08-03 276
二次判断类是否可独立实例化对象，内部类或者接口，抽象类都会对应生成一个.class文件，但是这些文件部分是不能够实例化的，不可以生成bean，所以在生成BeanDefinition之前需要进行过滤判断。对扫描到的BeanDefinition进行赋值，但是此时只是将className赋值到BeanDefinition中，因为还没有创建该类。spring在启动的时候就会往includeFilters中加入component注解。判断当前类是否需要当作bean进行处理。
【SpringBoot】 定时任务之任务执行和调度及使用指南
ToBeMaybe_的博客
08-03 946
本文将着重介绍Spring中的TaskExecutor接口、TaskScheduler接口、Trigger接口以及Spring中定时任务的任务执行和调度以及开发中的正确使用姿势。
linux安装weblogic
m0_46400195的博客
08-05 794
域文件位置就是python文件中设置的，位置（cd /root/web/weblogic/softWare/projects/doamins/testDomain）（以自己python为主）想要启动weblogic 12版本及以后都需要去oracle_common目录下配合启动脚本进行服务器启动。weblogic不允许root用户进行安装，所以要提前创建weblogic用户来进行安装。例如：http://192.168.0.143:7001/console。用户名：启动weblogic的用户名。
synchronized关键字的原理
09-22
synchronized关键字用于解决多个线程之间对共享资源的同步访问问题。它可以保证同一时间只有一个线程执行被它修饰的方法或者代码块。synchronized关键字的原理是通过加锁和释放锁的机制来实现的。当一个线程获得了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Listen·Rain

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

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

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

打赏作者

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

抵扣说明：

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

余额充值