使用Java代码实现zookeeper分布式锁

产生问题

例:在分布式(集群)环境下,每台JVM不能实现同步,比如将一个项目部署到多台tomcat服务器,那么用多台JVM在使用时间戳生成唯一的订单号时,会出现订单号重复问题。

解决办法:

分布式情况下,怎么解决订单号生成不重复:
1. 使用分布式锁
2. 提前生成好,订单号,存放在redis。获取订单号时,直接从redis中取。

实现分布式锁的方式

1.使用数据库实现分布式锁
缺点:性能差、线程出现异常时,容易出现死锁
2.使用redis实现分布式锁
缺点:锁的失效时间难控制、容易产生死锁、非阻塞式、不可重入
3.使用zookeeper实现分布式锁
实现相对简单、可靠性强、使用临时节点,失效时间容易控制

什么是分布式锁?

分布式锁一般用在分布式系统或者多个应用中,用来控制同一任务是否执行或者任务的执行顺序。在项目中,部署了多个tomcat应用,在执行定时任务时就会遇到同一任务可能执行多次的情况,我们可以借助分布式锁,保证在同一时间只有一个tomcat应用执行了定时任务。

使用Zookeeper实现分布式锁

Zookeeper实现分布式锁原理

使用zookeeper创建临时序列节点来实现分布式锁,适用于顺序执行的程序,大体思路就是创建临时序列节点,找出最小的序列节点,获取分布式锁,程序执行完成之后此序列节点消失,通过watch来监控节点的变化,从剩下的节点的找到最小的序列节点,获取分布式锁,执行相应处理,依次类推……

代码实现

Maven依赖

        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>

创建生成唯一订单类

public class OrderNumberGenerate {

    //全局订单ID
    private static Integer count = 0;

    public String getNumber(){
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd-hh-mm-ss");
        return format.format(new Date())+"-"+ ++count;
    }
}

创建Lock接口

public interface Lock {
    //获取锁资源
    public void getLock();
    //释放锁资源
    public void unlock();
}

创建ZookeeperAbstractLock抽象类,实现Lock接口

public abstract class ZookeeperAbstractLock implements Lock {

    //zk连接地址
    private static final String CONNECTSTRING = "127.0.0.1:2181";
    //创建zk连接
    protected ZkClient zkClient = new ZkClient(CONNECTSTRING);
    //PATH
    protected static final String PATH = "/lock";

    /** * 获取锁 */
    @Override
    public void getLock() {
        if(trylock()){
            System.out.println("###获取lock锁当资源###");
        } else{
            //等待锁
            waitLock();
            //重新获取锁
            getLock();
        }
    }

    /** * 释放锁 */
    @Override
    public void unlock() {
        if(zkClient!=null){
            zkClient.close();
            System.out.println("###释放所资源###");
        }
    }

    /** * 判断是否获取锁成功,成功返回true,失败返回false */
    abstract boolean trylock();
    /** * 等待锁 */
    abstract void waitLock();
}

创建ZookeeperDistributeLock类,继承ZookeeperAbstractLock类

public class ZookeeperDistributeLock extends ZookeeperAbstractLock {

    private CountDownLatch countDownLatch = null;

    @Override
    boolean trylock() {
        try {
            zkClient.createPersistent(PATH);
            return true;
        } catch (RuntimeException e) {
            //e.printStackTrace();
            return false;
        }
    }

    @Override
    void waitLock() {
        IZkDataListener iZkDataListener = new IZkDataListener() {
            /** * 当节点发生改变时 * @param s * @param o * @throws Exception */
            @Override
            public void handleDataChange(String s, Object o) throws Exception {

            }

            /** * 当节点被删除时 * @param s * @throws Exception */
            @Override
            public void handleDataDeleted(String s) throws Exception {
                //唤醒被等待的线程
                if (countDownLatch!=null) {
                    countDownLatch.countDown();
                }
            }
        };

         //注册事件
         zkClient.subscribeDataChanges(PATH,iZkDataListener);
         if(zkClient.exists(PATH)){
             countDownLatch = new CountDownLatch(1);
             try {
                 countDownLatch.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         //删除监听
         zkClient.unsubscribeDataChanges(PATH,iZkDataListener);
    }
}

创建多线程,使用Zookeeper锁运行

public class OrderService implements Runnable{

    OrderNumberGenerate generate = new OrderNumberGenerate();
    //使用自己创建的lock锁
    private Lock lock = new ZookeeperDistributeLock();
    @Override
    public void run() {
        try {
            //获取锁资源
            lock.getLock();
            getNumber();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁资源
            lock.unlock();
        }
    }
    //生成订单
    public void getNumber(){
        String number = generate.getNumber();
        System.out.println(Thread.currentThread().getName()+",生成订单ID:"+number);
    }

    public static void main(String[] args) {
        System.out.println("####生成唯一订单号###");
        for (int i=0;i<10;i++) {
            new Thread(new OrderService()).start();
        }
    }
}

运行结果

###获取lock锁当资源###
Thread-2,生成订单ID:2018-09-05-04-45-03-1
###释放所资源###
###获取lock锁当资源###
Thread-4,生成订单ID:2018-09-05-04-45-11-2
###释放所资源###
###获取lock锁当资源###
Thread-12,生成订单ID:2018-09-05-04-45-29-3
###释放所资源###
###获取lock锁当资源###
Thread-16,生成订单ID:2018-09-05-04-45-50-4
###释放所资源###
###获取lock锁当资源###
Thread-10,生成订单ID:2018-09-05-04-46-02-5
###释放所资源###
###获取lock锁当资源###
Thread-8,生成订单ID:2018-09-05-04-46-04-6
###释放所资源###
Thread-18,生成订单ID:2018-09-05-04-46-05-7
###释放所资源###
###获取lock锁当资源###
Thread-14,生成订单ID:2018-09-05-04-46-15-8
###释放所资源###
###获取lock锁当资源###
Thread-20,生成订单ID:2018-09-05-04-46-16-9
###释放所资源###
###获取lock锁当资源###
Thread-6,生成订单ID:2018-09-05-04-46-22-10
###释放所资源###
    原文作者:java锁
    原文地址: https://blog.csdn.net/yswKnight/article/details/82429391
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞