当前位置：首页 > news >正文

【java】synchronized关键字详解

news 来源：原创 2025/5/16 6:35:31

- 一、线程同步与线程安全问题
- - 线程不安全Demo
  - 线程不安全的原因
- 二、synchronized关键字
- - 关键字锁粒度
  - - 修饰对象
    - 修饰代码块
    - 修饰方法
    - 修饰静态方法
    - 修饰类
  - synchronized 锁总结
- synchronized加锁原理
- - MarkWord
  - synchronized锁升级
  - synchronized锁原理
  - synchronized关键字总结
- 其他同步方式
- - 乐观锁
  - Lock类的加锁、解锁
  - 分布式锁（redis）

一、线程同步与线程安全问题

线程不安全Demo

我们下面就看一个出现线程不安全情况的示例

class UnsafeThreadDemo {private int count;public MultiUnSafeDemo(int count) {this.count = count;}public void getAndIncrement() {count++;}public static void main(String[] args) throws InterruptedException {final MultiUnSafeDemo counter = new MultiUnSafeDemo(0);Thread []threads = new Thread[100];for(int i=0; i<threads.length; i++) {threads[i] = new Thread(() -> {for(int j=0; j<1000; j++) {counter.getAndIncrement();}});threads[i].start();}for(int i=0; i<threads.length; i++) {threads[i].join();}System.out.println("count: "+counter.count);}
}

运行结果，结果显示count并非100000，那又是为什么呢？
在这里插入图片描述

线程不安全的原因

问题出现在count++ 并非原子操作，i++分为三个步骤

读取当前值
当前值+1
写回内存

线程之间的切换，可能发生在任意过程，e.g. 线程a已经加完1，但是发生线程切换，当前值被原由的线程b的值覆盖，导致实际执行100个线程的总和并非100*1000，发生线程切换的位置可能导致实际值比理论值小。

二、synchronized关键字

java中提供了一些解决线程安全问题的工具，有Lock类，有synchronized关键字，这里先介绍synchronized关键字

关键字锁粒度

修饰对象

synchronized 可以修饰对象，例如通过new ClassName() 创建的对象，例如在代码的共享变量区域使用synchronized(this) ，可以保障线程安全，如果在第一部分的示例中使用synchronized(this) 覆盖 count++的代码块，可以保障最终的结果正确输出100000：

public class MultiUnSafeDemo {private int count;public MultiUnSafeDemo(int count) {this.count = count;}public void getAndIncrement() {synchronized (this) {count++;}}public static void main(String[] args) throws InterruptedException {final MultiUnSafeDemo counter = new MultiUnSafeDemo(0);Thread []threads = new Thread[100];for(int i=0; i<threads.length; i++) {threads[i] = new Thread(() -> {for(int j=0; j<1000; j++) {counter.getAndIncrement();}});threads[i].start();}for(int i=0; i<threads.length; i++) {threads[i].join();}System.out.println("count: "+counter.count);}
}

在这里插入图片描述
此时，由于代码的getAndIncrement方法被对象调用，因此synchronized (this) 等价于对象锁，锁的是调用这个方法的对象。通过this对象调用方法的synchornized，实现非原子性的**count++**操作的同步。

修饰代码块

除了修饰对象，可以将synchronized关键字修饰代码中共享变量的区域，保证操作共享变量的一致性。

public class Cache {private final Object lock = new Object();private Map<String, String> data = new HashMap<>();public void put(String key, String value) {synchronized (lock) { // 锁定私有对象，避免暴露锁data.put(key, value);}}
}

上述示例中，synchronized关键字修饰lock这个类的变量，实现操作data这个hashMap的线程同步性

修饰方法

可以将synchornized关键字添加到方法前，调用方法的时候会实现多线程的同步

  public synchronized void getAndIncrement() {count++;}

效果和在方法内部增加synchronized () {} 代码块相同，都是锁定这个实例

优点：实现简单，方便
缺点：可能将方法中不需要同步的部分也控制住，降低了程序的并发性。

修饰静态方法

等价于修饰类，因为静态方法的生命周期和类相同，因此在静态方法上加锁，锁定的是类所有实例，在一台机器上的对象实例都串行执行

修饰类

通过synchronized (XXXName.Class) 实现锁对象

public class DatabaseConnection {public void init() {// 同步代码块，锁定类的 Class 对象synchronized (DatabaseConnection.class) {// 初始化数据库连接（全局唯一操作）}}
}

锁的类型为类对象，适用场景为全局：

全局锁

synchronized 锁总结

Synchronized基于类、对象、方法、静态方法的使用修饰，有以下几种形式，整理为：

锁类型	锁对象	同步范围	适用场景
对象锁	对象实例，以及对象调用方法	当前实例的线程	非静态的示例方法
类锁	Class对象	所有实例的对象	静态变量保护或全局操作，例如数据库连接池的初始化
同步代码块	显示指定的对象	代码块包含的区域	同步耗时操作中的关键部分