使用AQS手动实现锁的获取与释放

1.使用AQS实现锁的代码

package cn.shiyujun.thread.thread4;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * 手动使用 AQS 实现锁的获取与释放
 */
public class MyLock2 implements Lock{

    private Hepler hepler = new Hepler();

    private class  Hepler extends AbstractQueuedSynchronizer{

        @Override
        protected boolean tryAcquire(int arg) {

            //  如果第一个线程进来，可以拿到锁，因此我们可以返回true

            //  如果第二个线程进来，则拿不到锁，返回false。有种特例，如果当前进来的线程和当前保存的线程是同一个线程，则可以拿到锁，但是有代价，要更新状态值

            //  如何判断是第一个线程进来还是其他线程进来？

            int state = getState();
            Thread t = Thread.currentThread();

            if(state == 0){
                if(compareAndSetState(0,arg)){
                    //设置当前线程
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
            }else if(getExclusiveOwnerThread() == t){ //判断进来的是不是当前线程，如果是当前线程状态加一，保证锁的重入
                setState(state + 1);
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {

            //  锁的获取与释放肯定是一一对应的，那么调用此方法的线程一定是当前线程

            if(Thread.currentThread() != getExclusiveOwnerThread()){ //不是当前线程抛出异常
                throw new RuntimeException();
            }

            int state = getState() - arg;
            boolean flag = false;

            if(state == 0){
                setExclusiveOwnerThread(null);
                flag = true;
            }

            setState(state);
            return flag;
        }

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

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

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

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

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

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

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

2.测试代码

package cn.shiyujun.thread.thread4;

public class Main {

    private int value;

    private MyLock2  lock = new MyLock2();

    public int next(){
        lock.lock();
        try {
            Thread.sleep(300);
            return value++;
        } catch (InterruptedException e) {
            throw new RuntimeException();
        }finally {
            lock.unlock();
        }

    }

    public void a(){
        lock.lock();
        System.out.println("a");
        b();
        lock.unlock();
    }

    public void b(){
        lock.lock();
        System.out.println("b");
        lock.unlock();
    }

    public static void main(String[] args) {
        Main m = new Main();

        //测试锁的重入
        new Thread(new Runnable() {
            @Override
            public void run() {
               m.a();
            }
        }).start();



        //测试AQS锁
       new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println(Thread.currentThread().getId() + " " + m.next());
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println(Thread.currentThread().getId() + " " + m.next());
                }
            }
        }).start();
    }
}