实现Java显式锁解析

导读:
本文分为三部分:

1. 实现lock锁部分
2. 用到的线程工具类
3. 测试代码与结果展示

实现代码如下:

public class SelfLock implements Lock {
    // state 表示获取到锁 state = 1 获取到了锁 state = 0 表示锁当前没有被拿到
    // 定义内部类继承AQS 重写独占式流程方法
    private static class Sync extends AbstractQueuedSynchronizer{
        @Override
        // 判断当前锁是否属于占用
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

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

        @Override
        protected boolean tryRelease(int arg) {
            if (getState() == 0){
                throw new UnsupportedOperationException();
            }
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        Condition newCondition(){
            return new ConditionObject();
        }
    }

    private final Sync sync = new Sync();

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

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(time));
    }

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

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }
}

辅助代码:

// 线程休眠工具类
public class SleepTools {

    public static void seconds(long sleepTime){
        try {
            Thread.sleep(sleepTime * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试代码如下:

public class LockTest {
    private void test(){
        final Lock lock = new SelfLock();

        class Worker extends Thread {
            @Override
            public void run() {
                lock.lock();
                try{
                    SleepTools.seconds(1);
                    // 打印当前线程名字

                    System.out.println(Thread.currentThread().getName());
                    SleepTools.seconds(1);
                } finally {
                    lock.unlock();
                }
                SleepTools.seconds(2);
            }
        }

        for (int i = 0; i < 10; i++) {
            Worker worker = new Worker();
            // 设置为守护线程
            worker.setDaemon(true);
            worker.start();
        }

        for (int i = 0; i < 10; i++) {
            SleepTools.seconds(1);
            System.out.println();
        }
    }

    public static void main(String[] args) {
        LockTest lockTest = new LockTest();
        lockTest.test();
    }

}

测试结果: