实现Java显式锁解析

淩亂°似流年 2021-12-01 10:41 286阅读 0赞

**导读:**  
本文分为三部分:

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

测试结果:  
![在这里插入图片描述][201907200924260.png]

[201907200924260.png]: /images/20211201/06383aa8a82449a59c00507d0404e264.png