当前位置：首页 > Java

java如何自定义锁

2026-03-19 03:41:31Java

自定义锁的实现方法

在Java中，可以通过实现java.util.concurrent.locks.Lock接口或继承AbstractQueuedSynchronizer（AQS）类来创建自定义锁。以下是两种常见的实现方式：

基于Lock接口实现

实现Lock接口需要重写以下核心方法：

public class CustomLock implements Lock {
    private boolean isLocked = false;
    private Thread lockedBy = null;
    private int lockCount = 0;

    @Override
    public synchronized void lock() {
        Thread currentThread = Thread.currentThread();
        while (isLocked && lockedBy != currentThread) {
            try {
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        isLocked = true;
        lockedBy = currentThread;
        lockCount++;
    }

    @Override
    public synchronized void unlock() {
        if (Thread.currentThread() != lockedBy) {
            throw new IllegalMonitorStateException("Calling thread has not locked this lock");
        }
        lockCount--;
        if (lockCount == 0) {
            isLocked = false;
            lockedBy = null;
            notify();
        }
    }

    // 其他方法实现...
}

基于AQS实现

AQS提供了更底层的同步机制：

public class CustomAqsLock extends AbstractQueuedSynchronizer {
    @Override
    protected boolean tryAcquire(int arg) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    @Override
    protected boolean tryRelease(int arg) {
        if (getExclusiveOwnerThread() != Thread.currentThread()) {
            throw new IllegalMonitorStateException();
        }
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    public void lock() {
        acquire(1);
    }

    public void unlock() {
        release(1);
    }
}

关键注意事项

实现自定义锁时需要考虑以下方面：

重入性：支持同一线程多次获取锁
公平性：可选择实现公平或非公平锁
中断处理：正确处理线程中断情况
性能优化：减少不必要的线程阻塞

测试自定义锁

验证自定义锁的正确性：

public class LockTest {
    private static final CustomLock lock = new CustomLock();
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            lock.lock();
            try {
                for (int i = 0; i < 1000; i++) {
                    counter++;
                }
            } finally {
                lock.unlock();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Counter: " + counter);
    }
}