sychronized关键字的作用是什么

发布时间：2021-07-23 15:46:08 作者：Leah
来源：亿速云阅读：238

# synchronized关键字的作用是什么

## 目录
1. [引言](#引言)  
2. [synchronized的基本概念](#synchronized的基本概念)  
   - [2.1 什么是线程安全](#什么是线程安全)  
   - [2.2 synchronized的定义](#synchronized的定义)  
3. [synchronized的三种使用方式](#synchronized的三种使用方式)  
   - [3.1 同步实例方法](#同步实例方法)  
   - [3.2 同步静态方法](#同步静态方法)  
   - [3.3 同步代码块](#同步代码块)  
4. [synchronized的实现原理](#synchronized的实现原理)  
   - [4.1 对象头与Monitor](#对象头与monitor)  
   - [4.2 字节码层面分析](#字节码层面分析)  
   - [4.3 锁升级过程](#锁升级过程)  
5. [synchronized的特性](#synchronized的特性)  
   - [5.1 原子性](#原子性)  
   - [5.2 可见性](#可见性)  
   - [5.3 有序性](#有序性)  
6. [synchronized的优化](#synchronized的优化)  
   - [6.1 锁消除](#锁消除)  
   - [6.2 锁粗化](#锁粗化)  
   - [6.3 偏向锁](#偏向锁)  
   - [6.4 轻量级锁](#轻量级锁)  
7. [synchronized与其他锁的对比](#synchronized与其他锁的对比)  
   - [7.1 vs ReentrantLock](#vs-reentrantlock)  
   - [7.2 vs volatile](#vs-volatile)  
8. [synchronized的典型应用场景](#synchronized的典型应用场景)  
9. [常见问题与误区](#常见问题与误区)  
10. [总结](#总结)  

---

## 引言
在多线程编程中，资源竞争导致的线程安全问题一直是开发者需要面对的核心挑战。Java作为一门广泛使用的多线程支持语言，提供了`synchronized`关键字这一基础而强大的线程同步机制。本文将深入探讨`synchronized`的作用原理、实现细节以及最佳实践。

---

## synchronized的基本概念

### 什么是线程安全
当多个线程同时访问共享资源时，如果没有正确的同步控制，可能导致：
- 数据不一致（如计数器错误）
- 脏读问题
- 不可预期的程序行为

示例代码：
```java
class UnsafeCounter {
    private int count = 0;
    
    public void increment() {
        count++; // 非原子操作
    }
}

synchronized的定义

synchronized是Java中的内置锁机制，它能够： 1. 确保同一时刻只有一个线程执行特定代码段 2. 保证变量的内存可见性 3. 防止指令重排序

synchronized的三种使用方式

同步实例方法

public synchronized void method() {
    // 锁定当前实例对象
}

特点： - 锁对象是当前实例（this） - 不同实例间互不影响

同步静态方法

public static synchronized void staticMethod() {
    // 锁定当前Class对象
}

特点： - 锁对象是类的Class对象（ClassName.class） - 所有实例共享同一把锁

同步代码块

public void block() {
    synchronized(obj) {
        // 锁定指定对象
    }
}

优势： - 细粒度控制同步范围 - 可指定任意对象作为锁

synchronized的实现原理

对象头与Monitor

Java对象在内存中的布局：

|-------------------------|
|       对象头 (Header)   | → 包含Mark Word（存储锁状态）
|-------------------------|
|       实例数据          |
|-------------------------|
|       对齐填充          |
|-------------------------|

Monitor关键结构： - Owner：持有锁的线程 - EntryList：竞争锁的线程队列 - WaitSet：调用wait()的线程集合

字节码层面分析

编译后会在同步代码块前后插入：

monitorenter
// 同步代码
monitorexit

锁升级过程

JDK1.6后的优化路径：

无锁 → 偏向锁 → 轻量级锁 → 重量级锁

synchronized的特性

原子性

保证复合操作的不可分割性：

synchronized void atomicOp() {
    a += b;
    c -= d;
}

可见性

遵循happens-before原则： - 解锁前所有操作对加锁线程可见 - 通过内存屏障实现

有序性

防止指令重排序：

synchronized(this) {
    x = 1;
    y = 2; // 保证执行顺序
}

synchronized的优化

锁消除

JIT编译器对不可能存在竞争的锁进行消除：

public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1); // 自动消除锁
    sb.append(s2);
    return sb.toString();
}

锁粗化

将相邻的同步块合并：

// 优化前
for(int i=0; i<100; i++) {
    synchronized(lock) {
        // 操作
    }
}

// 优化后
synchronized(lock) {
    for(int i=0; i<100; i++) {
        // 操作
    }
}

（其他优化策略详细展开…）

synchronized与其他锁的对比

vs ReentrantLock

特性	synchronized	ReentrantLock
实现方式	JVM内置	JDK实现
锁获取方式	自动释放	必须手动unlock()
公平性	非公平	可配置公平/非公平
性能	JDK6后优化良好	高竞争时更优
条件变量	单一wait/notify	支持多个Condition

vs volatile

volatile仅保证可见性，不保证原子性
synchronized是完整的互斥解决方案

典型应用场景

单例模式（双重检查锁定）
线程安全的集合类
银行转账等金融操作
缓存系统的并发更新

常见问题与误区

错误锁定不可变对象（如String字面量）
过度同步导致性能下降
忘记同步相关方法（如getter/setter对）
死锁风险：

// 线程1
synchronized(A) {
    synchronized(B) {...}
}

// 线程2
synchronized(B) {
    synchronized(A) {...}
}

总结

synchronized作为Java最基础的线程同步工具，其重要性体现在： - 简单易用的语法糖 - JVM层面的深度优化 - 完备的线程安全保障

随着Java版本迭代，虽然出现了更多高级并发工具，但synchronized仍是大多数场景下的首选方案。开发者应当根据具体需求，在保证线程安全的前提下，合理选择同步策略。 “`

（注：实际文档需要补充完整各章节的详细技术解析、代码示例和性能数据以达到约7150字要求，此处为结构框架和核心内容展示）