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

最新推荐文章于 2024-02-26 16:48:58 发布

杨林伟

最新推荐文章于 2024-02-26 16:48:58 发布

阅读量554

点赞数 2

分类专栏： # 分布式

本文链接：https://blog.csdn.net/qq_20042935/article/details/103236682

版权

分布式专栏收录该内容

46 篇文章 16 订阅

订阅专栏

代码已提交至Github，有兴趣的同学可以下载来看看（git版本号：bea4d6f7ec9f7309033bcfa43316a660171ae5b6）:https://github.com/ylw-github/Zookeeper-Demo

本文目录结构：
l____1. 知识点回顾
 l________1.1 多线程
 l________1.2 Java共享内存模型
 l____2. 分布式锁的解决方案
 l________2.1 单机系统下生成订单号ID
l________2.2 分布式场景下生成订单号ID
l____3. 使用Zookeeper实现分布式锁
 l____总结

1. 知识点回顾

1.1 多线程

多线程：多线程为了能够提高应用程序的运行效率，在一个进程中有多条不同的执行路径，同时并行执行，互不影响。

线程安全：当多个线程同时共享，同一个全局变量或静态变量，做写的操作时，可能会发生数据冲突问题，也就是线程安全问题。但是做读操作是不会发生数据冲突问题。

解决办法：使用同步代码块或者Lock锁机制，保证在多个线程共享同一个变量只能有一个线程进行操作。

1.2 Java共享内存模型

共享内存模型 指的就是Java内存模型(简称JMM)，JMM决定一个线程对共享变量的写入时,能对另一个线程可见。

从抽象的角度来看，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();
        }

    }
}

运行效果：
在这里插入图片描述

总结

在这里插入图片描述

杨林伟

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
分布式系列教程（11） -分布式协调工具Zookeeper（分布式锁实现）

代码已提交至Github，有兴趣的同学可以下载来看看（git版本号：bea4d6f7ec9f7309033bcfa43316a660171ae5b6）:https://github.com/ylw-github/Zookeeper-Demo本文目录结构：l____1. 知识点回顾l________1.1 多线程l________1.2 Java共享内存模型l____2. 分布式锁的解决方...
复制链接

扫一扫