【Android面试|华为|锁相关】- synchronize(this) 和 synchronize(class)有什么区别

HarmonyOS Developer2023-12-05 10:00

华为面试官问了其中一个问题

Q: synchronize(this) 和 synchronize(class)一样么？ 是否可以用synchronize(this) 来锁

A: 当使用 synchronized 加锁 class 时，无论共享一个对象还是创建多个对象，它们用的都是同一把锁，而使用 synchronized 加锁 this 时，只有同一个对象会使用同一把锁，不同对象之间的锁是不同的。

synchronized 用法

synchronized 可以用来修饰普通方法、静态方法和代码块。 ​

  1. 修饰普通方法
java 复制代码 
/**
 * synchronized 修饰普通方法
 */
public synchronized void method() {
    // .......
}

当 synchronized 修饰普通方法时，被修饰的方法被称为同步方法，其作用范围是整个方法，作用的对象是调用这个方法的对象。 ​

  1. 修饰静态方法
java 复制代码 
/**
 * synchronized 修饰静态方法
 */
public static synchronized void staticMethod() {
    // .......
}

当 synchronized 修饰静态的方法时，其作用的范围是整个方法，作用对象是调用这个类的所有对象。

  1. 修饰代码块
    为了减少锁的粒度，我们可以选择在一个方法中的某个部分使用 synchronized 来修饰（一段代码块），从而实现对一个方法中的部分代码进行加锁，实现代码如下：
java 复制代码 
public void classMethod() throws InterruptedException {
    // 前置代码...
    
    // 加锁代码
    synchronized (SynchronizedExample.class) {
        // ......
    }
    
    // 后置代码...
}

以上代码在执行时，被修饰的代码块称为同步语句块，其作用范围是大括号"{}"括起来的代码块，作用的对象是调用这个代码块的对象。

但以上代码，除了可以加锁 class 之外，还可以加锁 this，具体示例如下：

java 复制代码 
public void classMethod() throws InterruptedException {
    // 前置处理代码...
    synchronized (this) {
        // ......
    }
    // 后置处理代码...
}

那问题来了，使用 synchronized 加锁 this 和 class 的区别是什么？不都是加锁同一个类吗？ ​

答案还真不是，加锁 this 和 class 区别还是很大的。下面我们通过以下 4 个示例，来看二者之间的区别。

区别：

  1. 加锁 class 共享一个类实例
    首先，我们创建 5 个线程，调用同一个对象下 synchronized 加锁的 class 代码，具体示例如下：
java 复制代码 
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizedExample {

    public static void main(String[] args) {
        // 创建当前类实例
        final SynchronizedExample example = new SynchronizedExample();
        // 创建 5 个线程执行任务
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 调用 synchronized 修饰的 class 方法
                        example.classMethod();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    /**
     * synchronized 修饰的 class 方法
     * @throws InterruptedException
     */
    public void classMethod() throws InterruptedException {
        synchronized (SynchronizedExample.class) {
            System.out.println(String.format("当前执行线程:%s,执行时间:%s",
                    Thread.currentThread().getName(), new Date()));
            TimeUnit.SECONDS.sleep(1);
        }
    }
}

从上述结果可以看出，这 5 个线程共享的是同一把锁。

  1. 加锁 class 创建多个实例
    接下来，我们创建 5 个线程，调用不同对象下 synchronized 加锁的 class 代码，具体示例如下：
java 复制代码 
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizedExample {

    public static void main(String[] args) {
        // 创建 5 个线程执行任务
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 创建类实例
                        SynchronizedExample example = new SynchronizedExample();
                        // 调用 synchronized 修饰的 class 方法
                        example.classMethod();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    
    /**
     * synchronized 修饰的 class 方法
     * @throws InterruptedException
     */
    public void classMethod() throws InterruptedException {
        synchronized (SynchronizedExample.class) {
            System.out.println(String.format("当前执行线程:%s,执行时间:%s",
                    Thread.currentThread().getName(), new Date()));
            TimeUnit.SECONDS.sleep(1);
        }
    }
}

从上述结果可以看出，虽然是不同的对象，但它们使用的仍然是同一把锁。

  1. 加锁 this 共享一个类实例

接下来，我们创建 5 个线程，调用 synchronized 加锁 this 的示例。首先我们这 5 个线程调用同一个对象的加锁方法，示例代码如下：

java 复制代码 
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizedExample {

    public static void main(String[] args) {
        // 创建当前类实例
        final SynchronizedExample example = new SynchronizedExample();
        // 创建 5 个线程执行任务
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 调用 synchronized 修饰的 this 方法
                        example.thisMethod();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    
    /**
     * synchronized 修饰的 this 方法
     * @throws InterruptedException
     */
    public void thisMethod() throws InterruptedException {
        synchronized (this) {
            System.out.println(String.format("当前执行线程:%s,执行时间:%s",
                    Thread.currentThread().getName(), new Date()));
            TimeUnit.SECONDS.sleep(1);
        }
    }
}

从上述结果可以看出，以上线程使用的都是同一把锁。

  1. 加锁 this 创建多个类实例

最后一个示例最为特殊，我们使用 synchronized 加锁 this，让这 5 个线程调用各自创建对象的方法，具体示例如下：

java 复制代码 
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class SynchronizedExample {

    public static void main(String[] args) {
        // 创建 5 个线程执行任务
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 创建（多个）类实例
                        SynchronizedExample example = new SynchronizedExample();
                        // 调用 synchronized 修饰的 this 方法
                        example.thisMethod();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    
    /**
     * synchronized 修饰的 this 方法
     * @throws InterruptedException
     */
    public void thisMethod() throws InterruptedException {
        synchronized (this) {
            System.out.println(String.format("当前执行线程:%s,执行时间:%s",
                    Thread.currentThread().getName(), new Date()));
            TimeUnit.SECONDS.sleep(1);
        }
    }
}

从上述结果可以看出，当使用 synchronized 加锁 this 时，如果线程调用的不是同一个对象，那么这些线程之间使用的锁都是自己独立的锁，这个结果就和 synchronized 加锁 class 的结果完全不同了。

相关推荐
怕浪猫9 小时前
GEO 优化到底是什么？AI时代内容创作者必须懂的新技能
算法·面试·github
IT大白鼠15 小时前
搜索系列 · 第 08 篇——面试收官：高频题与全景总结
elasticsearch·面试·nosql
resh_people15 小时前
开源鸿蒙平台 KMP_CMP 三方库「Kermit」适配全流程
华为·开源·harmonyos
JAVA面经实录91717 小时前
线上故障标准处理流程【完整版｜面试背诵+生产落地】
java·面试·职场和发展
李游Leo17 小时前
HarmonyOS 7 EasyGo + ArkUI Navigation：平行视界主副页筛选事务与跨栏撤销一致性【鸿蒙心迹】
华为·harmonyos
HwJack2018 小时前
【共创稿事节】HarmonyOS 7空间应用的可用性测试和体验评估小方法分享
华为·harmonyos·可用性测试
m0_7381858218 小时前
Flutter 鸿蒙化实战：flutter_scankit 适配 OpenHarmony，华为 ScanKit 扫码
flutter·华为·harmonyos·鸿蒙
zhangfeng113318 小时前
Ag / Cu / Au / Ru / Ir / Rh银 铜 金 钌铱 铑 纳米尺度下的 导电性 + 扩散/迁移缺点
人工智能·华为·ai编程·npu
浪浪山_大橙子19 小时前
公司里的 AI，终于不只会聊天：我用 GPT‑6 把企业工作伙伴开源了
前端·后端·面试
无限码力19 小时前
华为OD面试手撕真题 【合并相邻且相等的元素】多语言题解
华为od·面试·华为od面试真题·华为od面试手撕真题·华为od面试算法真题
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02历年考研数学一、数学二、数学三真题试卷及答案PDF03国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）04Telegram APK 下载安装完整指南 — 2026年最新05GitHub 镜像站点06蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接07Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）082026 爱知・名古屋亚运会怎么看？直播平台+赛程安排分享09微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新10给AI一张“业务概念地图“：本体如何从哲学走向企业智能