当前位置：首页 > Java

java如何锁住资源

2026-03-23 22:16:15Java

锁住资源的方法

在Java中，可以通过多种方式实现对资源的锁定，确保多线程环境下的线程安全。以下是几种常见的锁机制及其使用方法。

synchronized关键字

使用synchronized关键字可以修饰方法或代码块，确保同一时间只有一个线程能访问被锁定的资源。

public class SynchronizedExample {
    private int count = 0;

    // 修饰方法
    public synchronized void increment() {
        count++;
    }

    // 修饰代码块
    public void incrementBlock() {
        synchronized (this) {
            count++;
        }
    }
}

ReentrantLock

ReentrantLock是java.util.concurrent.locks包下的显式锁，提供了比synchronized更灵活的锁定机制。

import java.util.concurrent.locks.ReentrantLock;

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

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

ReadWriteLock

ReadWriteLock适用于读多写少的场景，允许多个线程同时读取资源，但写入时独占锁。

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

public class ReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private int value = 0;

    public int getValue() {
        rwLock.readLock().lock();
        try {
            return value;
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void setValue(int newValue) {
        rwLock.writeLock().lock();
        try {
            value = newValue;
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

StampedLock

StampedLock是Java 8引入的锁，支持乐观读锁，适用于读操作远多于写操作的场景。

java如何锁住资源

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private final StampedLock lock = new StampedLock();
    private int value = 0;

    public int getValue() {
        long stamp = lock.tryOptimisticRead();
        int currentValue = value;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                currentValue = value;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return currentValue;
    }

    public void setValue(int newValue) {
        long stamp = lock.writeLock();
        try {
            value = newValue;
        } finally {
            lock.unlockWrite(stamp);
        }
    }
}