AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

JAVA同步锁 synchronized(this)、synchronized(class)与synchronized(Object)的区别

2022-06-30 214
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 利用实例介绍JAVA同步锁 synchronized(this)、synchronized(class)与synchronized(Object)的区别 
/**
 * synchronized(this) 只能锁当前对象
 * synchronized(A.class) 锁类，对类的所有实例生效
 */

public class Synchronized {
    public void method1() { // 锁当前对象
        try {
            synchronized (this) {
                System.out.println("this   method1 start time=" + System.currentTimeMillis());
                Thread.sleep(2000);
                System.out.println("this   method1 end time=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public synchronized void method2() { // 与method1存在竞争关系
        System.out.println("       method2 start time=" + System.currentTimeMillis());
        System.out.println("       method2 end time=" + System.currentTimeMillis());
    }

    public void method3() { // 锁类，对类的所有实例生效
        synchronized (Synchronized.class) {
            try {
                System.out.println("class  method3 start time=" + System.currentTimeMillis());
                Thread.sleep(4000);
                System.out.println("class  method3 end time=" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static synchronized void method4() { // 与method3存在竞争关系
        System.out.println("static method4 start time=" + System.currentTimeMillis());
        System.out.println("static method4 end time=" + System.currentTimeMillis());
    }

}

class Thread1 extends Thread {
    private Synchronized objectService;

    public Thread1(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method1();
    }
}

class Thread2 extends Thread {
    private Synchronized objectService;

    public Thread2(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method2();
    }
}

class Thread3 extends Thread {
    private Synchronized objectService;

    public Thread3(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method3();
    }
}

class Thread4 extends Thread {
    private Synchronized objectService;

    public Thread4(Synchronized objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        super.run();
        objectService.method4();
    }
}

class MainTest {
    public static void main(String[] args) {
        Synchronized service = new Synchronized();

        new Thread1(service).start();
        new Thread2(service).start();
        new Thread3(service).start();
        new Thread4(service).start();
    }
}

输出结果：

在这里插入图片描述
从时间线可以看出method1和method2、method3和method4存在竞争关系。
当一个线程访问Synchronized类的一个synchronized (this)同步代码块时，其它线程对同一个Synchronized类中其它的synchronized ()同步方法的访问将是堵塞；访问synchronized (Synchronized.class)同步代码块时， static synchronized同步方法的访问将是阻塞，这说明synchronized (this)和synchronized ()同步方法、synchronized (Synchronized.class)同步代码块和 static synchronized同步方法使用的对象监视器是一个。

synchronized同步方法和synchronized(this)同步代码块

/**
 * synchronized(this)锁定当前对象
 */

public class SynchronizedThis {
    public void methodA() {
        try {
            synchronized (this) {
                System.out.println("this methodA 线程名称:" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
                for (int i = 1; i <= 2; i++) {
                    System.out.println("this methodA 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                    Thread.sleep(100);
                }
                System.out.println("this methodA 线程名称:" + Thread.currentThread().getName() + " end  time=" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        synchronized (this) {
            try {
                System.out.println("this methodB 线程名称:" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
                for (int i = 1; i <= 2; i++) {
                    System.out.println("this methodB 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                    Thread.sleep(100);
                }
                System.out.println("this methodB 线程名称:" + Thread.currentThread().getName() + " end  time=" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void methodC() {
        try {
            System.out.println("     methodC 线程名称:" + Thread.currentThread().getName() + " begin time=" + System.currentTimeMillis());
            for (int i = 1; i <= 2; i++) {
                System.out.println("     methodC 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                Thread.sleep(100);
            }
            System.out.println("     methodC 线程名称:" + Thread.currentThread().getName() + " end  time=" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThisThreadA extends Thread {
    private SynchronizedThis synchronizedThis;

    public ThisThreadA(SynchronizedThis synchronizedThis) {
        super();
        this.synchronizedThis = synchronizedThis;
    }

    @Override
    public void run() {
        super.run();
        synchronizedThis.methodA();
    }
}

class ThisThreadB extends Thread {
    private SynchronizedThis synchronizedThis;

    public ThisThreadB(SynchronizedThis synchronizedThis) {
        super();
        this.synchronizedThis = synchronizedThis;
    }

    @Override
    public void run() {
        super.run();
        synchronizedThis.methodB();
    }
}

class ThisThreadC extends Thread {
    private SynchronizedThis synchronizedThis;

    public ThisThreadC(SynchronizedThis synchronizedThis) {
        super();
        this.synchronizedThis = synchronizedThis;
    }

    @Override
    public void run() {
        super.run();
        synchronizedThis.methodC();
    }
}

class ThisMainTest {
    public static void main(String[] args) {
        SynchronizedThis service = new SynchronizedThis();
        ThisThreadA a = new ThisThreadA(service);
        a.setName("ThreadA");
        a.start();
        ThisThreadB b = new ThisThreadB(service);
        b.setName("ThreadB");
        b.start();
        ThisThreadC c = new ThisThreadC(service);
        c.setName("ThreadC");
        c.start();
    }
}

输出结果
在这里插入图片描述

多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized(this)同步代码块时，是同步的。

synchronized同步方法和synchronized(this)同步代码块是相互竞争关系

  1. 对其它的synchronized同步方法或synchronized(this)同步代码块调用是堵塞状态；
  2. 同一时间只有一个线程执行synchronized同步方法或synchronized(this)同步代码块中的代码。

静态同步synchronized方法

/**
 * 静态同步synchronized方法
 * synchronized应用在static方法上，那是对当前对应的*.Class进行持锁。
 */
public class SynchronizedStatic {
    public synchronized static void methodA() {
        try {
            System.out.println("static methodA 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
            for (int i = 1; i <= 5; i++) {
                System.out.println("static methodA 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                Thread.sleep(1000);
            }
            System.out.println("static methodA 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void methodB() {
        System.out.println("static methodB 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
        System.out.println("static methodB 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
    }
}

class StaticThreadA extends Thread {
    @Override
    public void run() {
        SynchronizedStatic.methodA();
    }
}

class StaticThreadB extends Thread {
    @Override
    public void run() {
        SynchronizedStatic.methodB();
    }
}

class StaticMainTest {
    public static void main(String[] args) {
        StaticThreadA a = new StaticThreadA();
        a.setName("ThreadA");
        a.start();
        StaticThreadB b = new StaticThreadB();
        b.setName("ThreadB");
        b.start();
    }
}

输出结果
在这里插入图片描述
synchronized应用在static方法上，那是对当前对应的.Class进行持锁，与同步synchronized(.class)代码块作用一样。
对比下面代码进行验证

synchronized(*.class)代码块

/**
 * synchronized(*.class)代码块
 * 同步synchronized(*.class)代码块的作用其实和synchronized static方法作用一样。
 * Class锁对类的所有对象实例起作用。
 */
public class SynchronizedClass {
    public void methodA() {
        try {
            synchronized (SynchronizedClass.class) {
                System.out.println("class methodA 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
                for (int i = 1; i <= 5; i++) {
                    System.out.println("class methodA 线程名称:" + Thread.currentThread().getName() + "-->i=" + i);
                    Thread.sleep(1000);
                }
                System.out.println("class methodA 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void methodB() {
        synchronized (SynchronizedClass.class) {
            System.out.println("class methodB 线程名称:" + Thread.currentThread().getName() + " begin times:" + System.currentTimeMillis());
            System.out.println("class methodB 线程名称:" + Thread.currentThread().getName() + " end   times:" + System.currentTimeMillis());
        }
    }
}

class ClassThreadA extends Thread {
    private SynchronizedClass objectService;

    public ClassThreadA(SynchronizedClass objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        objectService.methodA();
    }
}

class ClassThreadB extends Thread {
    private SynchronizedClass objectService;

    public ClassThreadB(SynchronizedClass objectService) {
        super();
        this.objectService = objectService;
    }

    @Override
    public void run() {
        objectService.methodB();
    }
}

class ClassMainTest {
    public static void main(String[] args) {
        SynchronizedClass service = new SynchronizedClass();
        ClassThreadA a = new ClassThreadA(service);
        a.setName("ThreadA");
        a.start();
        ClassThreadB b = new ClassThreadB(service);
        b.setName("ThreadB");
        b.start();
    }
}

// Class锁对类的所有对象实例起作用。
class ClassMainTest2 {
    public static void main(String[] args) {
        SynchronizedClass service1 = new SynchronizedClass();
        SynchronizedClass service2 = new SynchronizedClass();
        ClassThreadA a = new ClassThreadA(service1);
        a.setName("ThreadA-service1");
        a.start();
        ClassThreadB b = new ClassThreadB(service2);
        b.setName("ThreadB-service2");
        b.start();
    }
}

输出结果
在这里插入图片描述

同步synchronized(*.class)代码块的作用其实和synchronized static方法作用一样。
Class锁对类的所有对象实例起作用。

文章标签：
Java
关键词：
Java synchronized区别
Java Synchronized
Java Object
object区别
Java Class
鳄鱼儿
目录
相关文章
运营研究坊
|
2月前
|
存储 缓存 人工智能
Java int和Integer的区别
本文介绍了Java中int与Integer的区别及==与equals的比较机制。Integer是int的包装类，支持null值。使用==比较时，int直接比较数值，而Integer比较对象地址；在-128至127范围内的Integer值可缓存，超出该范围或使用new创建时则返回不同对象。equals方法则始终比较实际数值。
运营研究坊
79 0
迷你熊爱你
|
19天前
|
Java 测试技术
Java浮点类型详解：使用与区别
Java中的浮点类型主要包括float和double，它们在内存占用、精度范围和使用场景上有显著差异。float占用4字节，提供约6-7位有效数字；double占用8字节，提供约15-16位有效数字。float适合内存敏感或精度要求不高的场景，而double精度更高，是Java默认的浮点类型，推荐在大多数情况下使用。两者都存在精度限制，不能用于需要精确计算的金融领域。比较浮点数时应使用误差范围或BigDecimal类。科学计算和工程计算通常使用double，而金融计算应使用BigDecimal。
迷你熊爱你
257 6
程序员小假
|
3月前
|
存储 Java C语言
Java List 复制：浅拷贝与深拷贝方法及区别
我是小假 期待与你的下一次相遇 ~
程序员小假
240 1
AI小云
|
2月前
|
安全 算法 Java
Java 中 synchronized 与 AtomicInteger 的区别
在Java多线程编程中，`synchronized`和`AtomicInteger`均用于实现线程安全，但原理与适用场景不同。`synchronized`是基于对象锁的同步机制，适用于复杂逻辑和多变量同步，如银行转账；而`AtomicInteger`采用CAS算法，适合单一变量的原子操作，例如计数器更新。二者各有优劣，应根据具体需求选择使用。
AI小云
69 0
34789737
|
3月前
|
算法 Java 数据库连接
Java 与 C++ 区别深入剖析及应用实例详解
本文深入剖析了Java和C++两种编程语言的区别，从编译与执行机制、面向对象特性、数据类型与变量、内存管理、异常处理等方面进行对比，并结合游戏开发、企业级应用开发、操作系统与嵌入式开发等实际场景分析其特点。Java以跨平台性强、自动内存管理著称，适合企业级应用；C++则因高性能和对硬件的直接访问能力，在游戏引擎和嵌入式系统中占据优势。开发者可根据项目需求选择合适语言，提升开发效率与软件质量。附面试资料链接：[点此获取](https://pan.quark.cn/s/4459235fee85)。
34789737
210 0
flzjkl
|
6月前
|
存储 缓存 人工智能
【原理】【Java并发】【synchronized】适合中学者体质的synchronized原理
本文深入解析了Java中`synchronized`关键字的底层原理，从代码块与方法修饰的区别到锁升级机制，内容详尽。通过`monitorenter`和`monitorexit`指令，阐述了`synchronized`实现原子性、有序性和可见性的原理。同时，详细分析了锁升级流程：无锁 → 偏向锁 → 轻量级锁 → 重量级锁，结合对象头`MarkWord`的变化，揭示JVM优化锁性能的策略。此外，还探讨了Monitor的内部结构及线程竞争锁的过程，并介绍了锁消除与锁粗化等优化手段。最后，结合实际案例，帮助读者全面理解`synchronized`在并发编程中的作用与细节。
flzjkl
362 8
【原理】【Java并发】【synchronized】适合中学者体质的synchronized原理
flzjkl
|
6月前
|
缓存 安全 Java
【Java并发】【synchronized】适合初学者体质入门的synchronized
欢迎来到我的Java线程同步入门指南！我不是外包员工，梦想是写高端CRUD。2025年我正在沉淀中，博客更新速度加快，欢迎点赞、收藏、关注。 本文介绍Java中的`synchronized`关键字，适合初学者。`synchronized`用于确保多个线程访问共享资源时不会发生冲突，避免竞态条件、保证内存可见性、防止原子性破坏及协调多线程有序访问。
flzjkl
156 8
【Java并发】【synchronized】适合初学者体质入门的synchronized
2G冲浪词条
|
4月前
|
Java
Java 中 Exception 和 Error 的区别
在 Java 中，`Exception` 和 `Error` 都是 `Throwable` 的子类，用于表示程序运行时的异常情况。`Exception` 表示可被捕获和处理的异常，分为受检异常（Checked）和非受检异常（Unchecked），通常用于程序级别的错误处理。而 `Error` 表示严重的系统级问题，如内存不足或 JVM 错误，一般不建议捕获和处理。编写程序时应重点关注 `Exception` 的处理，确保程序稳定性。
2G冲浪词条
107 0
Remember_Ray
|
6月前
|
安全 IDE Java
重学Java基础篇—Java Object类常用方法深度解析
Java中，Object类作为所有类的超类，提供了多个核心方法以支持对象的基本行为。其中，`toString()`用于对象的字符串表示，重写时应包含关键信息；`equals()`与`hashCode()`需成对重写，确保对象等价判断的一致性；`getClass()`用于运行时类型识别；`clone()`实现对象复制，需区分浅拷贝与深拷贝；`wait()/notify()`支持线程协作。此外，`finalize()`已过时，建议使用更安全的资源管理方式。合理运用这些方法，并遵循最佳实践，可提升代码质量与健壮性。
Remember_Ray
171 1
wanderInk
|
5月前
|
Java 编译器 程序员
java中重载和多态的区别
本文详细解析了面向对象编程中多态与重载的概念及其关系。多态是OOP的核心，分为编译时多态（静态多态）和运行时多态（动态多态）。编译时多态主要通过方法重载和运算符重载实现，如Java中的同名方法因参数不同而区分；运行时多态则依赖继承和方法重写，通过父类引用调用子类方法实现。重载是多态的一种形式，专注于方法签名的多样性，提升代码可读性。两者结合增强了程序灵活性与扩展性，帮助开发者更好地实现代码复用。
wanderInk
187 0

热门文章

最新文章

  • 1
    java调用api接口自动判断节假日信息
  • 2
    Java 基于 DDD 分层架构实战从基础到精通最新实操全流程指南
  • 3
    2025 年 Java 全栈从环境搭建到项目上线实操全流程指南：Java 全栈最新实操指南（2025 版）
  • 4
    Java中的Lambda表达式：简化代码的利器
  • 5
    Java Stream API：现代数据处理之道
  • 6
    Java 17 Switch表达式：更简洁、更强大的流程控制
  • 7
    解锁Java 17新利器：密封类（Sealed Classes）的精准控制
  • 8
    Java浮点类型详解：使用与区别
  • 9
    2025 Java 零基础到实战最新技术实操全攻略与学习指南
  • 10
    Java中的Switch表达式：更简洁的多路分支
  • 1
    综合案例【商品管理系统-Java基础版】（附完整源码）
    451
  • 2
    Java常见异常及对应解决办法
    164
  • 3
    19 Java8概述（Java8概述+lambda表达式+函数式接口+方法引用+Stream+新时间API）
    125
  • 4
    18 Java反射reflect（类加载+获取类对象+通用操作+设计模式+枚举+注解）
    270
  • 5
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（下）
    163
  • 6
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（中）
    168
  • 7
    17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（上）
    153
  • 8
    16 Java网络编程（计算机网络+网络模型OSI/TCP/IP+通信协议等）
    181
  • 9
    15 Java IO流（File类+IO流+字节流+字符流+字节编码）
    120
  • 10
    13 Java异常（异常过程解析、throw、throws、try-catch关键字）
    275

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    阿里云 EMR Serverless Spark 版开启免费公测