AQS实现 -- 自定义不可重入锁

悠悠 2022-12-08 15:53 148阅读 0赞

### 1、什么是AQS ###

![在这里插入图片描述][20200920233719523.png_pic_center]

### 2、自定义实现不可重入锁 ###

package AQS;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.AbstractQueuedSynchronizer;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    
    @Slf4j(topic = "c.自定义锁")
    public class 自定义锁 {
        
        public static void main(String[] args) {
        
            MyLock lock = new MyLock();
            new Thread(() -> {
        
                lock.lock();
                //lock.lock(); 		同一线程，测试是否不可重入
                try{
        
                    log.debug("lock.....");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                } finally {
        
                    log.debug("unlock....");
                    lock.unlock();
                }
            },"t1").start();
    
            new Thread(() -> {
        
                lock.lock();
                try{
        
                    log.debug("lock.....");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                } finally {
        
                    log.debug("unlock....");
                    lock.unlock();
                }
            },"t2").start();
        }
    
    }
    
    //自定义不可重入锁
    class MyLock implements Lock {
        
    
        //独占锁 同步器类
        class MySync extends AbstractQueuedSynchronizer {
        
    
            @Override
            protected boolean tryAcquire(int arg) {
        
                if(compareAndSetState(0,1)){
        
                    // 加上了锁，并设置owner 为当前线程
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
                return false;
            }
    
            @Override
            protected boolean tryRelease(int arg) {
        
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
    
            @Override   //是否持有独占锁
            protected boolean isHeldExclusively() {
        
                return getState() == 1;
            }
    
            public Condition newCondition(){
        
                return new ConditionObject();
            }
        }
    
        private MySync sync = new MySync();
    
        @Override   // 加锁，不成功会进入等待队列
        public void lock() {
        
            sync.acquire(1);
        }
    
        @Override   // 加锁，可打断
        public void lockInterruptibly() throws InterruptedException {
        
            sync.acquireInterruptibly(1);
        }
    
        @Override   //尝试加锁（1次）
        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();
        }
    }

输出：

23:32:58.809 [t1] DEBUG c.自定义锁 - lock.....
    23:32:59.815 [t1] DEBUG c.自定义锁 - unlock....
    23:32:59.815 [t2] DEBUG c.自定义锁 - lock.....
    23:33:00.816 [t2] DEBUG c.自定义锁 - unlock....

[20200920233719523.png_pic_center]: /images/20221123/e0877957e044495e9c534ddd8b9868f8.png