五.Curator实现分布式锁

最新推荐文章于 2025-03-09 02:33:51 发布

风云159

最新推荐文章于 2025-03-09 02:33:51 发布

阅读量1k

点赞数

分类专栏： zookeeper源码分析

本文链接：https://blog.youkuaiyun.com/js54100804/article/details/78885081

版权

zookeeper源码分析专栏收录该内容

5 篇文章

订阅专栏

InterProcessMutex:全局可重入锁，客户端都可以请求锁，并且同一个客户端在拥有锁的同时，可以多次获取，不会被阻塞。客户端在拥有锁的同时，可以多次获取，不会被阻塞。

package DistributeLock;

import java.util.concurrent.TimeUnit;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;

/**
 * 这个类负责请求锁，使用资源，释放锁这个完整的访问流程
 * */
public class ExampleClientThatLocks
{
    private final InterProcessMutex lock;//全局可重入锁
    private final FakeLimitedResource resource;//共享资源
    private final String clientName;
    public ExampleClientThatLocks(CuratorFramework client,String lockPath, FakeLimitedResource resource, String clientName)
    {
        this.lock = new InterProcessMutex(client, lockPath);
        this.resource = resource;
        this.clientName = clientName;
    }
    public void doWork(long time,TimeUnit unit) throws Exception{
        //尝试获取锁，如果无法获取锁，抛出异常
        if(!lock.acquire(time, unit)){
            throw new IllegalStateException(clientName + "不能获取锁");
        }
        System.out.println(clientName +"获得了锁");
        if(!lock.acquire(time, unit)){
            throw new IllegalStateException(clientName + "不能再次获取锁");
        }
        System.out.println(clientName +"再次获得了锁(重入功能)");
        try{
            resource.use();
        }finally{
            System.out.println(clientName + "释放了锁");
            lock.release();
            lock.release();
        }
        
    }
    
    
}

package DistributeLock;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 模拟共享资源，这个资源期望只能单线程访问，否则会有并发问题（走到抛异常的逻辑）
 * <br>
 */
public class FakeLimitedResource {
    private final AtomicBoolean inUse = new AtomicBoolean(false);

    public void use() throws InterruptedException {
        /**
         * inUse.compareAndSet(false, true)表示：先检测当前值是否为false,如果为false,就更新为true
         * 如果多个线程执行这个方法，在无锁的情况下，由于下面睡了一段时间，所以有些线程会走到抛异常的地方
         */
        if (!inUse.compareAndSet(false, true)) { 
            throw new IllegalStateException("Needs to be used by one client at a time");
        }
        try {
            Thread.sleep(5000);
        } finally {
            inUse.set(false);
        }
    }
    public void read(){
        System.out.println(inUse.get());
    }
}

package DistributeLock;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

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.curator.test.TestingServer;
import org.apache.curator.utils.CloseableUtils;
/**
 *可重入锁InterProcessMutex例子 
 *
 */
public class InterProcessMutexExample
{   
    private static final String PATH = "/examples/locks";
    public static void main(String[] args) throws Exception
    {
        //共享资源
        final FakeLimitedResource resource = new FakeLimitedResource();
        //有50个线程的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 5);
       
        //10个线程，模拟10个客户端
        for(int i=0;i<10;++i){
            final int index = i;
            Callable<Void> task = new Callable<Void>()
            {

                public Void call() throws Exception
                {
                    //2.通过工厂建立连接
                    CuratorFramework client = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181")
                            .sessionTimeoutMs(5000)
                            .retryPolicy(retryPolicy)
                            .build();
                    try
                    {
                        client.start();
                        ExampleClientThatLocks example = new ExampleClientThatLocks(client, PATH, resource,"client" + index);
                        //每个客户端重复5次任务
                        for(int j=0;j<5;++j){
                            example.doWork(10, TimeUnit.SECONDS);
                        }
                    }
                    catch (Exception e)
                    {
                       e.printStackTrace();
                    }finally{
                        CloseableUtils.closeQuietly(client);//关闭该客户端
                    }
                    
                    return null;
                }
            };
            service.submit(task);
        }
        service.shutdown();
        
    }
}

代码也很简单，生成10个client，每个client重复执行5次请求锁–访问资源–释放锁的过程。每个client都在独立的线程中。结果可以看到，锁是随机的被每个客户端实例排他性的使用。既然是可重用的，你可以在一个线程中多次调用acquire,在线程拥有锁时它总是返回true。

你不应该在多个线程中用同一个InterProcessMutex，你可以在每个线程中都生成一个InterProcessMutex实例，它们的path都一样，这样它们可以共享同一个锁。

InterProcessSemaphoreMutex：不可重入锁
这个锁和上面的相比，就是少了Reentrant的功能，也就意味着它不能在同一个线程中重入。这个类是InterProcessSemaphoreMutex。使用方法和上面的类类似。

我们将上面的例子修改一下，测试一下它的重入,修改ExampleClientThatLocks.doWork,连续两次acquire。现在第二次acquire进不去了。

package curatorExample.DistributeLock;


import java.util.concurrent.TimeUnit;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.framework.recipes.locks.InterProcessSemaphoreMutex;
/**
 * 测试不可重入锁
 * 这个类负责请求锁，使用资源，释放锁这个完整的访问流程
 * */
public class ExampleClientThatLocks2
{
    private final InterProcessSemaphoreMutex lock;//全局可重入锁
    private final FakeLimitedResource resource;//共享资源
    private final String clientName;
    public ExampleClientThatLocks2(CuratorFramework client,String lockPath, FakeLimitedResource resource, String clientName)
    {
        this.lock = new InterProcessSemaphoreMutex(client, lockPath);//不可重入的锁
        this.resource = resource;
        this.clientName = clientName;
    }
    public void doWork(long time,TimeUnit unit) throws Exception{
        //尝试获取锁，如果无法获取锁，抛出异常
        if(!lock.acquire(time, unit)){
            throw new IllegalStateException(clientName + "不能获取锁");
        }
        System.out.println(clientName +"获得了锁");
        //现在这里不能重入了
        if(!lock.acquire(time, unit)){
            throw new IllegalStateException(clientName + "不能再次获取锁");
        }
        System.out.println(clientName +"再次获得了锁(重入功能)");
        try{
            resource.use();
        }finally{
            System.out.println(clientName + "释放了锁");
            lock.release();
            lock.release();
        }
        
    }
}

InterProcessReadWriteLock：可重入读写锁

类似JDK的ReentrantReadWriteLock. 一个读写锁管理一对相关的锁。一个负责读操作，另外一个负责写操作。读操作在写锁没被使用时可同时由多个进程使用，而写锁使用时不允许读 (阻塞)。此锁是可重入的。一个拥有写锁的线程可重入读锁，但是读锁却不能进入写锁。这也意味着写锁可以降级成读锁，比如请求写锁 —>读锁 —->释放写锁。从读锁升级成写锁是不成的。

主要由两个类实现：

InterProcessReadWriteLock
InterProcessLock

使用时首先创建一个InterProcessReadWriteLock实例，然后再根据你的需求得到读锁或者写锁，读写锁的类型是InterProcessLock。
public InterProcessLock readLock()
public InterProcessLock writeLock()

package curatorExample.DistributeLock;


import java.util.Random;
import java.util.concurrent.TimeUnit;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.recipes.locks.InterProcessLock;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.framework.recipes.locks.InterProcessReadWriteLock;


public class ExampleClientReadWriteLocks
{
    private final InterProcessReadWriteLock lock;
    private final InterProcessLock readLock;
    private final InterProcessLock writeLock;
    private final FakeLimitedResource resource;
    private final String clientName;
    public ExampleClientReadWriteLocks(CuratorFramework client, String lockPath, FakeLimitedResource resource, String clientName) {
        this.resource = resource;
        this.clientName = clientName;
        lock = new InterProcessReadWriteLock(client, lockPath);
        readLock = lock.readLock();
        writeLock = lock.writeLock();
    }
    public void doWork(long time,TimeUnit unit) throws Exception{
        Random rand = new Random();
        int random_data = rand.nextInt();
        try{
            if(random_data %10 == 0){
                //尝试获取写锁，
                if(!writeLock.acquire(time, unit)){
                    throw new IllegalStateException(clientName + "不能获得写锁");
                }
                System.out.println(clientName + " 获得了写锁");  
                resource.use();  
            }else{
                //尝试获取读锁
                if(!readLock.acquire(time, unit)){
                    throw new IllegalStateException(clientName + "不能获得读锁");
                }
                System.out.println(clientName + " 获得了读锁");
                resource.read();
                
            } 
        }finally{
            System.out.println(clientName + " 释放锁");
            if(writeLock.isAcquiredInThisProcess())
                writeLock.release(); 
            if(readLock.isAcquiredInThisProcess())
                readLock.release(); 
        }
        
        
        
        
    }
}

package curatorExample.DistributeLock;



import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

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.curator.utils.CloseableUtils;

public class InterProcessReadWriteLockExample
{
    private static final String PATH = "/examples/locks";
    public static void main(String[] args) throws Exception
    {
        //共享资源
        final FakeLimitedResource resource = new FakeLimitedResource();
        //有10个线程的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 5);
       
        //10个线程，模拟10个客户端
        for(int i=0;i<10;++i){
            final int index = i;
            Callable<Void> task = new Callable<Void>()
            {

                public Void call() throws Exception
                {
                    //2.通过工厂建立连接
                    CuratorFramework client = CuratorFrameworkFactory.builder().connectString("192.168.10.110:2181,192.168.10.111:2181,192.168.10.112:2181")
                            .sessionTimeoutMs(5000)
                            .retryPolicy(retryPolicy)
                            .build();
                    try
                    {
                        client.start();
                        ExampleClientReadWriteLocks example = new ExampleClientReadWriteLocks(client, PATH, resource,"client" + index);
                        //每个客户端重复5次任务
                        for(int j=0;j<5;++j){
                            example.doWork(10, TimeUnit.SECONDS);
                        }
                    }
                    catch (Exception e)
                    {
                       e.printStackTrace();
                    }finally{
                        CloseableUtils.closeQuietly(client);//关闭该客户端
                    }
                    
                    return null;
                }
            };
            service.submit(task);
        }
        service.shutdown();
    }
}