当前位置：首页 > Java

如何实现锁java

2026-03-24 18:12:04Java

实现锁的几种方法

在Java中，可以通过多种方式实现锁机制，每种方法适用于不同的场景。以下是几种常见的实现方式：

synchronized关键字

synchronized是Java中最基本的锁机制，可以用于方法或代码块。它确保同一时间只有一个线程可以访问被锁定的资源。

如何实现锁java

public class Counter {
    private int count = 0;

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

ReentrantLock

ReentrantLock是java.util.concurrent.locks包中的一个类，提供了比synchronized更灵活的锁机制。支持公平锁和非公平锁。

如何实现锁java

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();
        }
    }
}

ReadWriteLock

ReadWriteLock接口提供了读写分离的锁机制，允许多个线程同时读取资源，但写操作是独占的。

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

public class SharedResource {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private String data;

    public String readData() {
        rwLock.readLock().lock();
        try {
            return data;
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void writeData(String newData) {
        rwLock.writeLock().lock();
        try {
            data = newData;
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

StampedLock

StampedLock是Java 8引入的一种锁机制，支持乐观读锁和悲观读锁，适用于读多写少的场景。

import java.util.concurrent.locks.StampedLock;

public class Point {
    private double x, y;
    private final StampedLock lock = new StampedLock();

    public void move(double deltaX, double deltaY) {
        long stamp = lock.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public double distanceFromOrigin() {
        long stamp = lock.tryOptimisticRead();
        double currentX = x;
        double currentY = y;
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}