Java Lua 分布式锁实现 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
###释放所资源###