Java Lock 锁如何实现公平锁和非公平锁

Java中的Lock接口提供了两种锁：公平锁（Fair Lock）和非公平锁（Unfair Lock）。公平锁意味着等待时间最长的线程将获得锁，而非公平锁则不保证这一点。这两种锁的实现方式如下：

1. 公平锁（Fair Lock）：

Java中的ReentrantLock类可以通过构造函数参数设置为公平锁。当设置为公平锁时，等待时间最长的线程将获得锁。为了实现公平锁，我们需要自定义一个队列来存储等待获取锁的线程。以下是一个简单的公平锁实现示例：

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

public class FairLock implements Lock {
    private final AbstractOwnableSynchronizer synchronizer = new AbstractOwnableSynchronizer() {
        @Override
        protected boolean tryAcquire(int acquires) {
            Thread currentThread = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors()) {
                    setState(c + acquires);
                    return true;
                }
            } else if (currentThread == getExclusiveOwnerThread()) {
                setState(c + acquires);
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException();
            }
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        @Override
        protected Condition newCondition() {
            return null;
        }
    };

    @Override
    public void lock() {
        synchronizer.acquire(1);
    }

    @Override
    public void unlock() {
        synchronizer.release(1);
    }

    @Override
    public boolean isLocked() {
        return synchronizer.isHeldExclusively();
    }

    @Override
    public boolean isHeldByCurrentThread() {
        return synchronizer.getExclusiveOwnerThread() == Thread.currentThread();
    }
}

2. 非公平锁（Unfair Lock）：

Java中的ReentrantLock类默认实现为非公平锁。在非公平锁中，等待时间最长的线程不一定能获得锁。以下是一个简单的非公平锁实现示例：

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

public class UnfairLock implements Lock {
    private final AbstractOwnableSynchronizer synchronizer = new AbstractOwnableSynchronizer() {
        @Override
        protected boolean tryAcquire(int acquires) {
            Thread currentThread = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors()) {
                    setState(c + acquires);
                    return true;
                }
            } else if (currentThread == getExclusiveOwnerThread()) {
                setState(c + acquires);
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread()) {
                throw new IllegalMonitorStateException();
            }
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        @Override
        protected Condition newCondition() {
            return null;
        }
    };

    @Override
    public void lock() {
        synchronizer.acquire(1);
    }

    @Override
    public void unlock() {
        synchronizer.release(1);
    }

    @Override
    public boolean isLocked() {
        return synchronizer.isHeldExclusively();
    }

    @Override
    public boolean isHeldByCurrentThread() {
        return synchronizer.getExclusiveOwnerThread() == Thread.currentThread();
    }
}

请注意，这里的公平锁和非公平锁实现仅作为示例，实际生产环境中建议使用Java内置的ReentrantLock类。