Zookeeper学习

导入依赖

<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>5.1.0</version>
</dependency>

<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>5.1.0</version>
</dependency>

使用Curator操作API

import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.zookeeper.data.Stat;
import org.junit.After;
import org.junit.Before;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.nio.charset.StandardCharsets;
import java.util.List;

@SpringBootTest
class CuratorZkApplicationTests {

    private CuratorFramework client;

    /**
     * 在其他方法执行前先执行此方法
     * 创建连接
     */
    @Before
    public void connection() {
        // 重试策略
        RetryPolicy retry = new ExponentialBackoffRetry(3000, 10);
        // 创建连接
        client = CuratorFrameworkFactory
                .builder()
                .connectString("192.168.0.110:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retry)
                .namespace("molu").build();
        //开启连接
        client.start();
    }

    /**
     * 创建节点
     * 1.创建子节点
     * 2.创建节点并设置值
     * 3.创建多级节点
     */
    @Test
    public void create() throws Exception {
        // 创建基本节点,如果创建的节点没有数据,则默认把当前机的ip作为数据填充
        String path = client.create().forPath("molu");
        System.out.println("path = " + path);
        // 创建节点,并添加数据,添加数据时需要字节数组类型的值
        String forPath = client.create().forPath("molu", "value值".getBytes(StandardCharsets.UTF_8));
        System.out.println("forPath = " + forPath);
        // forPath()方法创建节点时,父节点不存在时不支持创建,会抛出异常
        client.create().forPath("/aaa/ccc");
        // 创建多级节点,如果父节点不存在则创建父节点
        String s = client.create().creatingParentsIfNeeded().forPath("app/p1");
        System.out.println("s = " + s);
    }

    /**
     * 修改数据
     * 1.直接修改
     * 2.根据版本号修改(推荐)
     */
    public void set() throws Exception {
        // 直接修改数据
        Stat app = client.setData().forPath("app", "hahahahah哈哈哈哈".getBytes(StandardCharsets.UTF_8));
        System.out.println("app = " + app);
        // 查询状态数据,获取版本号
        Stat stat = new Stat();
        client.getData().storingStatIn(stat).forPath("app");
        // 根据版本号修改
        client.setData().withVersion(stat.getVersion()).forPath("app", "嘻嘻嘻".getBytes(StandardCharsets.UTF_8));
        System.out.println(client.getData().forPath("app"));
    }

    /**
     * 删除
     * 1.删除单个节点
     * 2.删除该节点及其子节点
     * 3.一定删除成功
     * 4.删除后回调
     */
    public void delete() throws Exception {
        // 删除当前节点(删除单个)
        client.delete().forPath("app");
        // 删除当前节点及其子节点
        client.delete().deletingChildrenIfNeeded().forPath("app");
        // 必须删除成功
        client.delete().guaranteed().forPath("app");
    }

    /**
     * 查询:
     * 1.查询数据:get
     * 2.查询子节点:ls
     * 3. 查询状态:ls -s
     */
    @Test
    public void query() throws Exception {
        // 查询数据
        String app = new String(client.getData().forPath("app"));
        System.out.println("app = " + app);
        // 查询子节点
        List<String> list = client.getChildren().forPath("app");
        System.out.println("list = " + list);
        // 查询状态,创建一个对象,获取到状态后 会把数据映射到当前对象中
        Stat stat = new Stat();
        client.getData().storingStatIn(stat).forPath("app");
        // 获取到状态数据
        System.out.println("stat = " + stat);
    }

    /**
     * 在所有方法执行完成后在执行此方法
     * 关闭连接释放资源
     */
    @After
    public void close(){
        if (client != null) {
            client.close();
        }
    }

}

分布式锁原理

Curator分布式锁API

使用分布式锁模拟卖票

import lombok.extern.slf4j.Slf4j;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMultiLock;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;
import java.util.concurrent.TimeUnit;


@Slf4j
public class Ticket implements Runnable {

    // 数据库中有1000张票
    private int ticket = 1000;

    // 分布式锁实现类
    private InterProcessMutex lock;

    public Ticket(){
        RetryPolicy retry = new ExponentialBackoffRetry(3000, 10);
        // 创建连接
        CuratorFramework client = CuratorFrameworkFactory
                .builder()
                .connectString("192.168.0.110:2181")
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retry).build();
        //开启连接
        client.start();
        lock = new InterProcessMutex(client, "/lock");
    }


    @Override
    public void run() {
        while (true) {
            try {
                // 获取锁
                lock.acquire(10, TimeUnit.SECONDS);
                if (ticket > 0) {
                    log.info("{}-->{}", Thread.currentThread(), ticket);
                    Thread.sleep(100);
                    ticket--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    // 释放锁
                    lock.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class Consumer {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();
        // 模拟三个平台售票
        Thread t1 = new Thread(ticket, "携程");
        Thread t2 = new Thread(ticket, "飞猪");
        Thread t3 = new Thread(ticket, "12306");

        t1.start();
        t2.start();
        t3.start();
    }
}