通过示例讲解Java有哪些加锁方式

2025-06-18 10:20:35 作者：五道书童

在Java中加锁是一种同步机制,用于控制对共享资源的并发访问,以防止多个线程同时修改数据,从而避免数据不一致和并发问题,这篇文章主要介绍了Java有哪些加锁方式的相关资料,需要的朋友可以参考下

在Java中，加锁的方式主要有以下几种：

1. synchronized 关键字

synchronized 是Java中最基本的加锁机制，可以用于方法或代码块。

实例方法：

public synchronized void method() {
    // 同步代码
}

锁的是当前实例对象。

静态方法：

public static synchronized void staticMethod() {
    // 同步代码
}

锁的是当前类的 Class 对象。

代码块：

public void method() {
    synchronized (this) {
        // 同步代码
    }
}

锁的是指定对象。

2. ReentrantLock

ReentrantLock 是 java.util.concurrent.locks 包中的类，提供了比 synchronized 更灵活的锁机制。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Example {
    private final Lock lock = new ReentrantLock();

    public void method() {
        lock.lock();  // 加锁
        try {
            // 同步代码
        } finally {
            lock.unlock();  // 释放锁
        }
    }
}

3. ReadWriteLock

ReadWriteLock 是一种读写锁，允许多个读线程同时访问，但写线程独占锁。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Example {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void readMethod() {
        rwLock.readLock().lock();
        try {
            // 读操作
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void writeMethod() {
        rwLock.writeLock().lock();
        try {
            // 写操作
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

4. StampedLock

StampedLock 是Java 8引入的锁机制，支持乐观读锁、悲观读锁和写锁。

import java.util.concurrent.locks.StampedLock;

public class Example {
    private final StampedLock stampedLock = new StampedLock();

    public void readMethod() {
        long stamp = stampedLock.readLock();
        try {
            // 读操作
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }

    public void writeMethod() {
        long stamp = stampedLock.writeLock();
        try {
            // 写操作
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    public void optimisticReadMethod() {
        long stamp = stampedLock.tryOptimisticRead();
        // 读操作
        if (!stampedLock.validate(stamp)) {
            stamp = stampedLock.readLock();
            try {
                // 重新读操作
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
    }
}

5. Semaphore

Semaphore 是一种计数信号量，用于控制同时访问特定资源的线程数量。

import java.util.concurrent.Semaphore;

public class Example {
    private final Semaphore semaphore = new Semaphore(10); // 允许10个线程同时访问

    public void method() throws InterruptedException {
        semaphore.acquire();  // 获取许可
        try {
            // 同步代码
        } finally {
            semaphore.release();  // 释放许可
        }
    }
}

6. Condition

Condition 通常与 ReentrantLock 配合使用，用于线程间的协调。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Example {
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void awaitMethod() throws InterruptedException {
        lock.lock();
        try {
            condition.await();  // 等待
        } finally {
            lock.unlock();
        }
    }

    public void signalMethod() {
        lock.lock();
        try {
            condition.signal();  // 唤醒
        } finally {
            lock.unlock();
        }
    }
}

7. Atomic 类

Atomic 类（如 AtomicInteger、AtomicReference 等）通过CAS（Compare-And-Swap）实现无锁同步。

import java.util.concurrent.atomic.AtomicInteger;

public class Example {
    private final AtomicInteger atomicInteger = new AtomicInteger(0);

    public void increment() {
        atomicInteger.incrementAndGet();  // 原子操作
    }
}

8. LockSupport

LockSupport 提供了线程阻塞和唤醒的基本操作。

import java.util.concurrent.locks.LockSupport;

public class Example {
    public void parkMethod() {
        LockSupport.park();  // 阻塞当前线程
    }

    public void unparkMethod(Thread thread) {
        LockSupport.unpark(thread);  // 唤醒指定线程
    }
}

总结

synchronized：简单易用，适合大多数场景。
ReentrantLock：提供更多功能，如可中断锁、超时锁等。
ReadWriteLock：适合读多写少的场景。
StampedLock：性能更高，适合复杂场景。
Semaphore：控制资源访问数量。
Condition：用于线程间协调。
Atomic 类：无锁同步，适合简单操作。
LockSupport：底层线程阻塞和唤醒工具。

根据具体需求选择合适的加锁方式。

到此这篇关于Java有哪些加锁方式的文章就介绍到这了,更多相关Java加锁方式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！