简介

  临近过年了，没什么需求，今天模仿ReentrantLock自定义写了一个自己锁，在这里记录一下，前提是对AQS原理有所了解，分享给大家

1、自定义锁MyLock

package com.jacky;import java.util.concurrent.TimeUnit;import java.util.concurrent.locks.AbstractQueuedSynchronizer;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;/** * Created by jacky on 2018/2/12. */public class MyLock implements Lock{    private final Sync sync;    /**     * 创建公平锁或非公平锁     * @param fairFlag     */    public MyLock(boolean fairFlag){       sync = fairFlag ? new FairSync() : new NonFairSync();    }    /**     * 默认是公平锁     */    public MyLock(){        sync = new FairSync();    }    /**     * 获取锁     */    @Override    public void lock() {         sync.acquire(1);    }    /**     * 获取可中断锁     * @throws InterruptedException     */    @Override    public void lockInterruptibly() throws InterruptedException {        sync.acquireInterruptibly(1);    }    /**     * 它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，     * 也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待     * @return     */    @Override    public boolean tryLock() {        return sync.nonfairTryAcquire(1);    }    /**     * 获得可超时的锁     * @param time     * @param unit     * @return     * @throws InterruptedException     */    @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.new ConditionObject();    }    abstract static class Sync extends AbstractQueuedSynchronizer {        /**         * 判断当前线程是否获得锁         * @return         */        @Override        protected boolean isHeldExclusively() {            return Thread.currentThread() ==getExclusiveOwnerThread();        }        /**         * 尝试释放锁         * @param arg         * @return         */        @Override        protected boolean tryRelease(int arg) {            int newState =getState()-arg;            setState(newState < 0 ? 0:newState);            if (newState ==0){                setExclusiveOwnerThread(null);            }            return true;        }        final boolean nonfairTryAcquire(int arg) {            Thread thread = Thread.currentThread();            int state = getState();            if (state ==0){                compareAndSetState(0,state+arg);                //设置独占线程                setExclusiveOwnerThread(thread);                return true;            }            if (isHeldExclusively()){                setState(state+arg);                return true;            }            return false;        }    }    static class FairSync extends Sync{        /**         * 尝试公平锁获得锁         * @param arg         * @return         */        @Override        public boolean tryAcquire(int arg) {            Thread thread = Thread.currentThread();            int state = getState();            if (state ==0){                //判断队列是否有数据，有数据就返回获取锁失败(公平锁才会这么做)                if (hasQueuedPredecessors()){                    return false;                }                compareAndSetState(0,state+arg);                //设置独占线程                setExclusiveOwnerThread(thread);                return true;            }            if (isHeldExclusively()){                setState(state+arg);                 return true;            }            return false;        }    }    static class NonFairSync extends Sync{        @Override        public boolean tryAcquire(int arg) {            return  nonfairTryAcquire(arg);        }    }}

2、测试类

package com.jacky;import jdk.internal.org.objectweb.asm.tree.TryCatchBlockNode;import java.util.concurrent.CountDownLatch;import java.util.concurrent.locks.ReentrantLock;/** * Created by jacky on 2018/2/12. */public class MyLockDemo {    private final static MyLock lock = new MyLock(false);    //private final static ReentrantLock lock = new ReentrantLock(true);    private static int num = 0;    public static void main(String[] args) {        int count = 2000;        CountDownLatch countDownLatch = new CountDownLatch(count);        Runnable runnable = new Runnable() {            @Override            public void run() {                try {                    lock.lock();                Thread thread = Thread.currentThread();                System.out.println("--start--"+thread.getName());                try {                    Thread.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }                num++;                System.out.println("--end--");                countDownLatch.countDown();                }finally {                   lock.unlock();                }            }        };        Thread thread = null;        for (int i = 0; i < count; i++) {            thread = new Thread(runnable,"t"+i);            thread.start();        }        try {            countDownLatch.await();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("--num--"+num);    }}