实现一个java锁

AQS是实现java锁的核心，但是实现起来还是仅仅只需继承该类重写它的几个主要方法即可。

1.首先，定义一个同步类，继承AQS。

//这里要有个Sync内部类,实现锁需要继承AQS
private static class MySync extends AbstractQueuedSynchronizer {
    /**
     * 使用CAS尝试改变同步状态,抢锁就使用cas将当前线程设置状态为1，设置owner为当前线程
     * @param arg 设置状态锁必须要设置为1
     * @return
     */
    @Override
    protected boolean tryAcquire(int arg) {
        if(arg !=1){
            throw new RuntimeException("args 不为1");
        }
        //使用CAS尝试改变同步状态
        if(compareAndSetState(0,1)){
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    /**
     * 释放锁不需要cas操作
     * @param arg
     * @return
     */
    @Override
    protected boolean tryRelease(int arg) {
        if(getState()==0){
            throw new IllegalMonitorStateException();
        }
        //设置锁不被任何线程持有
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    @Override
    protected boolean isHeldExclusively() {
        return getState()==1;
    }
}
2.要实现锁，自然要定义我自己的锁了，如下

/**
 * 手动是实现java的锁机制
 * 这里主要要实现几个方法：tryLock，lock，unlock
 */
public class MyLock implements Lock {
　　
　　//这里引用刚才的aqs子类
    private MySync mySync=new MySync();

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

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

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

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

    @Override
    public Condition newCondition() {
        return null;
    }
    @Override
    public void lockInterruptibly() throws InterruptedException {

    }
}

好了，仅仅两个类即可搞定。下面来测试下是否好使。先定义一个线程，使用自己实现的锁

public class MyThread implements Runnable{

    MyLock myLock = new MyLock();
    @Override
    public void run() {
        try {
            myLock.lock();
            TimeUnit.SECONDS.sleep(3);
            System.out.println(Thread.currentThread().getName()+"	"+"正在执行..."+ DateUtil.now());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            myLock.unlock();
        }

    }
}

最后，测试类如下，我们开启10个线程小试一把，

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        for (int i = 0; i < 10; i++) {
            new Thread(myThread,i+"-thread").start();
        }
    }
}

输出结果截图如下：

而注销掉加锁的两行，则

效果很明显了