Synchronized、lock和volatile的原理分别是什么_synchronized和lock和volatile的区别以及它们的原理-CSDN博客

本文链接：https://blog.csdn.net/github_35942716/article/details/140741637

在 Java 中，synchronized、lock 和 volatile 是三种用于实现线程同步和保证并发安全的机制。它们在原理和应用场景上各有不同。下面详细介绍它们的原理和使用方法。

1. synchronized

原理

synchronized 是 Java 中最基本的同步机制，用于在方法或代码块上加锁，以保证同一时刻只有一个线程可以执行被同步的方法或代码块。

锁对象：每个 synchronized 块都有一个锁对象，当一个线程进入同步块时，它会获取这个锁对象。其他线程在获取该锁之前无法进入同步块。
内置锁（Intrinsic Lock）：每个对象在 Java 中都可以作为锁，称为内置锁或监视器锁。

用法

同步方法：锁是该方法所属对象（实例方法）或类对象（静态方法）。

public synchronized void syncMethod() {
    // 线程安全代码
}

public static synchronized void syncStaticMethod() {
    // 线程安全代码
}

同步代码块：锁是括号内指定的对象。

public void syncBlock() {
    synchronized (this) {
        // 线程安全代码
    }
}

public void syncStaticBlock() {
    synchronized (MyClass.class) {
        // 线程安全代码
    }
}

优点和缺点

优点：简单易用，容易理解。
缺点：会导致线程阻塞，可能会产生性能问题，且粒度较粗。

2. Lock

原理

Lock 是 Java 5 引入的一个更灵活的同步机制，定义在 java.util.concurrent.locks 包中。Lock 提供了比 synchronized 更细粒度的锁控制和更多的功能，如可重入、可中断、超时获取锁等。

可重入锁（ReentrantLock）：是 Lock 接口的常用实现类，提供与 synchronized 类似的功能，但更灵活。

用法

获取和释放锁：使用 lock() 获取锁，使用 unlock() 释放锁。

private final ReentrantLock lock = new ReentrantLock();

public void lockMethod() {
    lock.lock();
    try {
        // 线程安全代码
    } finally {
        lock.unlock();
    }
}

优点和缺点

优点：提供了比 synchronized 更多的功能和更高的性能，可以实现非阻塞获取锁。
缺点：需要显式地获取和释放锁，代码更复杂。

3. volatile

原理

volatile 是一种轻量级的同步机制，用于保证变量在多个线程之间的可见性。

可见性：当一个线程修改 volatile 变量的值时，新的值会立即刷新到主内存中，其他线程读取时可以立即得到最新的值。
有序性：禁止指令重排序优化。

用法

声明变量：使用 volatile 关键字声明变量。
```
private volatile boolean flag = true;
```

优点和缺点

优点：开销较低，简单易用，适用于状态标志等简单场景。
缺点：不保证原子性，不能用于复合操作（如自增、自减等）。

4. 适用场景

synchronized：适用于需要简单的、块级别的同步，适合方法同步或对象级别的同步。
Lock：适用于需要复杂同步控制，如可中断、超时获取锁，适合高并发场景。
volatile：适用于需要保证变量可见性但不需要原子性的场景，如状态标志、配置刷新等。

5. 示例对比

synchronized 示例

public class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

Lock 示例

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

volatile 示例

public class Flag {
    private volatile boolean flag = true;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public boolean isFlag() {
        return flag;
    }
}