分布式锁的三种实现方式

/** * 该类实现Lock类,用于分布式锁(也可以不实现该类,自己添加lock和unlock方法) * 实现思路: * 1.在数据库中建立一张表,创建一个属性唯一的字段 * 2.当有用户访问时,先查询该字段是否有指定的值, * 如果有则说明该数据正在被访问,拒绝其他用户进行写操作 * 如果没有则向数据库添加指定的值(上锁) * 3.该用户用完需要的数据后删除表中添加的指定数据(解锁) */public class MysqlLock implements Lock {    @Autowired    TestLockMapper testLockMapper;    private static final String FLAG = "isLock";
    /**     * 上锁就是向数据库中加上一条数据,该字段设置为唯一     * 当其他人想上锁时发现该数据有人占用就会等待     */    @Override    public void lock() {        while(true){            //循环直到获取到锁            boolean b = tryLock();    //如果锁被占用则获取不到            if(b){                TestLock testLock = new TestLock();                testLock.setFlag(FLAG);                testLockMapper.insert(testLock);                break;            }else {                System.out.println("该数据被占用...请等待。。。");            }        }    }
    @Override    public void lockInterruptibly() throws InterruptedException {
    }
    /**     * 尝试获取锁,如果数据库中有该值,则获取不到锁     * @return     */    @Override    public boolean tryLock() {        QueryWrapper<TestLock> wrapper = new QueryWrapper<>();        wrapper.eq("flag",FLAG);        TestLock testLock = testLockMapper.selectOne(wrapper);        if(testLock==null){            return  true;        }        return false;    }
    @Override    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {        return false;    }
    /**     * 释放锁,将上锁时设置的数据删除,其他请求可以设置数据来得到锁     */    @Override    public void unlock() {        QueryWrapper<TestLock> wrapper = new QueryWrapper<>();        wrapper.eq("flag",FLAG);        testLockMapper.delete(wrapper);    }
    @Override    public Condition newCondition() {        return null;    }}

/** * 实现思路 * 基本和mysql一致 * 在redis中使用命令判断该值是否存在,存在则等待,不存在则设置值,获取锁 * 当操作完成后删除值并且释放锁 */public class RedisLock {    @Autowired    RedisTemplate redisTemplate;    private static final String NAME = "lock";    private static final String FLAG = "isLock";    public void lock(){        while (true){        //向redis中设置指定的key/value,       //该方法有可能导致死锁        //    Boolean b = redisTemplate.opsForValue().setIfAbsent(NAME, FLAG);       //设置过期时间为 1 分钟 ,即使1分钟后没有人释放锁他也会自动消失            Boolean b = redisTemplate.opsForValue().setIfAbsent(NAME, FLAG,1, TimeUnit.MINUTES);            if (b){                return ;            }else{                System.out.println(" 该数据被占用...请等待。。。");            }        }    }
    public void unlock(){        redisTemplate.delete(NAME);    }
}

public class ZkLock {    //ZooKeeper客户端    private ZooKeeper zk;    //zk的一个目录结构locks,代表根目录    private String root ="/locks";    //锁的名称    private String lockName;    //当前线程创建的序列node    private ThreadLocal<String> nodeId = new ThreadLocal<>();    //用来同步等待zkclient链接到了服务端   //CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待    private CountDownLatch countDownLatch = new CountDownLatch(1);    //超时时间    private static final int sessionTimeout = 3000;    private final static byte[] data = new byte[0];    //在构造方法中连接zookeeper,创建根节点lock    public  ZkLock(String config,String lockName){        this.lockName = lockName;        try {            zk = new ZooKeeper(config, sessionTimeout, new Watcher() {//watcher用于监听                @Override                public void process(WatchedEvent event) {                    if(event.getState()==Event.KeeperState.SyncConnected){                        //递减锁存器的计数，如果计数到达零，则释放所有等待的线程。                        countDownLatch.countDown();                    }                }            });            //使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断。            countDownLatch.await();            Stat stat = zk.exists(root,false);            if(null==stat){                //创建根节点                zk.create(root,data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);            }        } catch (Exception e) {            e.printStackTrace();        }    }
    /**     * 添加watch监听临时顺序节点的删除     */    class LockWatcher implements Watcher {        private CountDownLatch latch = null;        public  LockWatcher(CountDownLatch latch) {            this.latch = latch;        }        @Override        public void process(WatchedEvent event) {            if(event.getType()== Event.EventType.NodeDeleted){                latch.countDown();            }        }    }
    public void lock(){        try{            //创建临时子节点            String myNode = zk.create(root+"/"+lockName,data,ZooDefs.Ids.OPEN_ACL_UNSAFE,                    CreateMode.EPHEMERAL_SEQUENTIAL);            System.out.println(Thread.currentThread().getName()+myNode+"created");            //取出所有子节点,并排序            List<String> subNode = zk.getChildren(root,false);            TreeSet<String> sortedNode = new TreeSet<>();            for (String node: subNode) {                sortedNode.add(root+"/"+node);            }            String smallNode = sortedNode.first();            if(myNode.equals(smallNode)){                //如果是最小节点,则表示获得锁                this.nodeId.set(myNode);                return;            }            String preNode = sortedNode.lower(myNode);            CountDownLatch latch = new CountDownLatch(1);            Stat stat = zk.exists(preNode,new LockWatcher(latch));//同时注册监听            //判断比自己小一个数的节点是否存在,如果不存在则不等待锁,同时注册监听            if(stat != null){                latch.await();//等待其他线程释放锁                nodeId.set(myNode);                latch = null;            }
        } catch (Exception e) {            e.printStackTrace();        }    }
    public void unlock(){        try {            if(null!= nodeId){                zk.delete(nodeId.get(),-1);            }            nodeId.remove();//释放锁        } catch (Exception e) {            e.printStackTrace();        }
    }
}