分布式系列教程（11） -分布式协调工具Zookeeper（分布式锁实现）-阿里云开发者社区

从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

下面通过示意图来说明这两个步骤：

如上图所示，本地内存A和B有主内存中共享变量x的副本。假设初始时，这三个内存中的x值都为0。线程A在执行时，把更新后的x值（假设值为1）临时存放在自己的本地内存A中。当线程A和线程B需要通信时，线程A首先会把自己本地内存中修改后的x值刷新到主内存中，此时主内存中的x值变为了1。随后，线程B到主内存中去读取线程A更新后的x值，此时线程B的本地内存的x值也变为了1。

从整体来看，这两个步骤实质上是线程A在向线程B发送消息，而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。

总结什么是Java内存模型?

java内存模型简称JMM，定义了一个线程对另一个线程可见。共享变量存放在主内存中，每个线程都有自己的本地内存，当多个线程同时访问一个数据的时候，可能本地内存没有及时刷新到主内存，所以就会发生线程安全问题。

2. 分布式锁的解决方案

下面举例：生成订单号ID，有什么方案呢？

2.1 单机系统下生成订单号ID

有三种：

使用时间戳
使用UUID
推特 (Twitter) 的 Snowflake 算法（雪花算法）生成唯一 ID。

下面使用代码来认知下吧：

1.生成订单类：

package com.ylw.zookeeper.lock;
import java.text.SimpleDateFormat;
import java.util.Date;
public class OrderNumGenerator {
    //全局订单id
    public static int count = 0;
    public String getNumber() {
        try {
            Thread.sleep(200);
        } catch (Exception e) {
        }
        SimpleDateFormat simpt = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
        return simpt.format(new Date()) + "-" + ++count;
    }
}

2.使用多线程情况模拟生成订单号

package com.ylw.zookeeper.lock;
public class OrderService implements Runnable {
    private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
    public void run() {
        getNumber();
    }
    public void getNumber() {
        String number = orderNumGenerator.getNumber();
        System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
    }
    public static void main(String[] args) {
        System.out.println("####生成唯一订单号###");
        for (int i = 0; i < 100; i++) {
            new Thread(new OrderService()).start();
        }
    }
}

3.多线程生成订单号，线程安全问题解决（使用synchronized或者lock锁）

Synchronized同步代码块方式：

package com.ylw.zookeeper.lock;
public class OrderServiceSync implements Runnable {
    private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
    public void run() {
        getNumber();
    }
    public void getNumber() {
        synchronized (this) {
            String number = orderNumGenerator.getNumber();
            System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
        }
    }
    public static void main(String[] args) {
        System.out.println("####生成唯一订单号###");
        OrderService orderService = new OrderService();
        for (int i = 0; i < 100; i++) {
            new Thread(orderService).start();
        }
    }
}

Lock锁方式：

package com.ylw.zookeeper.lock;
import java.util.concurrent.locks.ReentrantLock;
public class OrderServiceSyncLock implements Runnable {
    private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
    // 使用lock锁
    private java.util.concurrent.locks.Lock lock = new ReentrantLock();
    public void run() {
        getNumber();
    }
    public void getNumber() {
        try {
            // synchronized (this) {
            lock.lock();
            String number = orderNumGenerator.getNumber();
            System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
            // }
        } catch (Exception e) {
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        System.out.println("####生成唯一订单号###");
        OrderService orderService = new OrderService();
        for (int i = 0; i < 100; i++) {
            new Thread(orderService).start();
        }
    }
}

2.2 分布式场景下生成订单号ID

1.在分布式情况下，生成全局订单号ID，会有什么问题呢？

答：在分布式(集群)环境下，每台JVM不能实现同步，在分布式场景下使用时间戳生成订单号可能会重复。

2.那么该怎么解决？

使用分布式锁
提前生成好，订单号，存放在redis取。获取订单号，直接从redis中取。

3.有什么技术可以解决？

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

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

3. 使用Zookeeper实现分布式锁

使用zookeeper创建临时序列节点来实现分布式锁，适用于顺序执行的程序。

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

下面开始来讲解下代码：

1.添加maven依赖

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

2.创建Lock接口

package com.ylw.zookeeper.lock.zk;
public interface Lock {
    //获取到锁的资源
    void getLock();
    // 释放锁
    void unLock();
}

3.创建ZookeeperAbstractLock抽象类

package com.ylw.zookeeper.lock.zk;
import org.I0Itec.zkclient.ZkClient;
/**
 * 将重复代码写入子类中..
 */
public abstract class ZookeeperAbstractLock implements Lock {
    // zk连接地址
    private static final String CONNECTSTRING = "192.168.162.131:2181";
    // 创建zk连接
    protected ZkClient zkClient = new ZkClient(CONNECTSTRING);
    protected static final String PATH = "/lock";
    public void getLock() {
        if (tryLock()) {
            System.out.println("##获取lock锁的资源####");
        } else {
            // 等待
            waitLock();
            // 重新获取锁资源
            getLock();
        }
    }
    // 获取锁资源
    abstract boolean tryLock();
    // 等待
    abstract void waitLock();
    public void unLock() {
        if (zkClient != null) {
            zkClient.close();
            System.out.println("释放锁资源...");
        }
    }
}

4.创建ZookeeperDistrbuteLock类

package com.ylw.zookeeper.lock.zk;
import org.I0Itec.zkclient.IZkDataListener;
import java.util.concurrent.CountDownLatch;
public class ZookeeperDistrbuteLock extends ZookeeperAbstractLock {
    private CountDownLatch countDownLatch = null;
    @Override
    boolean tryLock() {
        try {
            zkClient.createEphemeral(PATH);
            return true;
        } catch (Exception e) {
//      e.printStackTrace();
            return false;
        }
    }
    @Override
    void waitLock() {
        IZkDataListener izkDataListener = new IZkDataListener() {
            public void handleDataDeleted(String path) throws Exception {
                // 唤醒被等待的线程
                if (countDownLatch != null) {
                    countDownLatch.countDown();
                }
            }
            public void handleDataChange(String path, Object data) throws Exception {
            }
        };
        // 注册事件
        zkClient.subscribeDataChanges(PATH, izkDataListener);
        if (zkClient.exists(PATH)) {
            countDownLatch = new CountDownLatch(1);
            try {
                countDownLatch.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 删除监听
        zkClient.unsubscribeDataChanges(PATH, izkDataListener);
    }
}

5.使用Zookeeper锁运行效果

package com.ylw.zookeeper.lock.old;
import java.util.concurrent.locks.ReentrantLock;
public class OrderServiceSyncLock implements Runnable {
    private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
    // 使用lock锁
    private java.util.concurrent.locks.Lock lock = new ReentrantLock();
    public void run() {
        getNumber();
    }
    public void getNumber() {
        try {
            // synchronized (this) {
            lock.lock();
            String number = orderNumGenerator.getNumber();
            System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
            // }
        } catch (Exception e) {
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) {
        System.out.println("####生成唯一订单号###");
        OrderService orderService = new OrderService();
        for (int i = 0; i < 100; i++) {
            new Thread(orderService).start();
        }
    }
}

运行效果：

分布式系列教程（11） -分布式协调工具Zookeeper（分布式锁实现）

1. 知识点回顾

1.1 多线程

1.2 Java共享内存模型

2. 分布式锁的解决方案

2.1 单机系统下生成订单号ID

2.2 分布式场景下生成订单号ID

3. 使用Zookeeper实现分布式锁

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

分布式系列教程（11） -分布式协调工具Zookeeper（分布式锁实现）

1. 知识点回顾

1.1 多线程

1.2 Java共享内存模型

2. 分布式锁的解决方案

2.1 单机系统下生成订单号ID

2.2 分布式场景下生成订单号ID

3. 使用Zookeeper实现分布式锁

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景