Java高并发详解：synchronized关键字

最新推荐文章于 2023-11-23 11:18:19 发布

Jaksioncc

最新推荐文章于 2023-11-23 11:18:19 发布

阅读量609

点赞数

分类专栏： Java高并发文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_37712731/article/details/128864311

版权

Java高并发专栏收录该内容

1 篇文章 0 订阅

订阅专栏

基本使用

Java中的synchronized关键字用于在多线程环境下确保数据同步。它可以用来修饰方法和代码块

当一个线程访问一个对象的synchronized方法或代码块时，其他线程将无法访问该对象的其他synchronized方法或代码块。这样可以确保在同一时间只有一个线程能够执行该代码块或方法，避免了多线程环境下的数据不一致问题

例如：

public class SynchronizedExample {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

在上面的代码中，increment()方法是一个synchronized方法。当多个线程访问这个方法时，只有一个线程能够执行该方法的代码，其他线程将被阻塞

synchronized关键字也可以用来修饰代码块，如：

public void increment() {
    synchronized(this) {
        count++;
    }
}

在上面的代码中，synchronized关键字修饰的是一个代码块，并且锁对象是当前对象(this)

注意：synchronized关键字会导致线程上下文切换和资源竞争，所以在使用时要注意性能问题

源码解析

底层实现是通过 Java 虚拟机（JVM）的对象头和监视器锁机制实现的

具体来说，当一个线程访问一个对象的 synchronized 方法或代码块时，它会试图获取该对象的监视器锁。如果该锁未被其他线程占用，该线程将获得该锁并执行代码；如果该锁被其他线程占用，该线程将进入阻塞状态，等待获取该锁

这里给出一份简化的 synchronized 关键字的源码：

public void synchronized method() {
    // 加锁
    Monitor.enter(this);
    try {
        // 同步代码块
    } finally {
        // 释放锁
        Monitor.exit(this);
    }
}

在这份代码中，方法通过调用 Monitor.enter 方法获取当前对象的监视器锁，并在 finally 块中调用 Monitor.exit 方法释放该锁。因此，在 synchronized 方法内部的代码可以保证在任意时刻只有一个线程可以访问

底层原理

Synchronized 关键字的底层源码是由 Java 编译器在编译期间生成的

当使用 synchronized 关键字修饰方法时，编译器会在该方法的字节码中插入 monitor 指令，用于管理该方法的访问顺序

当使用 synchronized 关键字修饰代码块时，编译器会生成两个字节码指令：monitorenter 和 monitorexit，用于在该代码块的开始和结束处加锁和解锁

以下是 synchronized 关键字修饰方法的示例汇编代码：

0: aload_0        # 加载 this 引用
1: dup            # 复制 this 引用
2: astore_1       # 将复制的 this 引用存入局部变量 1
3: monitorenter   # 对局部变量 1 上的对象加锁
4: ...            # 同步方法体
5: aload_1        # 重新加载 this 引用
6: monitorexit    # 对局部变量 1 上的对象解锁
7: ...

以下是 synchronized 关键字修饰代码块的示例汇编代码：

0: aload_1        # 加载 synchronized 关键字后的对象引用
1: dup            # 复制对象引用
2: astore_2       # 将复制的对象引用存入局部变量 2
3: monitorenter   # 对局部变量 2 上的对象加锁
4: ...            # 同步代码块体
5: aload_2        # 重新加载对象引用
6: monitorexit    # 对局部变量 2 上的

使用案例代码

public class Bank {
    private int balance = 100;

    public synchronized int getBalance() {
        return balance;
    }

    public synchronized void deposit(int amount) {
        balance += amount;
    }

    public synchronized void withdraw(int amount) {
        balance -= amount;
    }
}

public class User extends Thread {
    private Bank bank;
    private int amount;

    public User(Bank bank, int amount) {
        this.bank = bank;
        this.amount = amount;
    }

    public void run() {
        bank.withdraw(amount);
        System.out.println("User completed withdrawal, balance: " + bank.getBalance());
    }
}

public class Main {
    public static void main(String[] args) {
        Bank bank = new Bank();
        for (int i = 0; i < 100; i++) {
            User user = new User(bank, 10);
            user.start();
        }
    }
}