redis和zk分布式锁实现

淩亂°似流年 2022-04-08 09:53 203阅读 0赞

分布式锁  
场景演示为什么需要分布式锁  
场景：一个订单表，库存表，支付表，多个用户对库存操作。当前库存为1  
public class Order \{  
public void createOrder()\{  
System.out.println(Thread.currentThread().getName()+" 创建订单");  
\}  
\}

public class Pay \{  
public static void pay()\{  
System.out.println(Thread.currentThread().getName()+" 支付成功！");  
\}  
\}  
public class Stock \{  
private static Integer COUNT = 1;  
public boolean reduceStock()\{  
if(COUNT > 0)\{  
COUNT – ;  
return true;  
\}  
return false;  
\}  
\}

如图所示：

模拟了两个用户对库存只有一时，两个用户都成功减库存成功了，并且支付成功了，所有在分布式系统中，需要有分布式锁控制同一时间只有一个用户进来访问。  
分布式系统：表示有多个进程提供服务，完成一件事。

public class Main \{  
//模拟两个用户同时抢订单  
public static void main(String\[\] args) \{  
Thread user1 = new Thread(new UserThread(),“user1”);  
Thread user2 = new Thread(new UserThread(),“user2”);  
user1.start();  
user2.start();  
\}  
static class UserThread implements Runnable\{  
@Override  
public void run() \{  
new Order().createOrder();  
Boolean result = new Stock().reduceStock();  
if(result)\{  
System.out.println(Thread.currentThread().getName() + " 减库存成功");  
new Pay().pay();  
\}else\{  
System.out.println(Thread.currentThread().getName()+" 减库存失败");

}
        }
    }

redis分布式锁实现  
package com.wf.springdemo.locktest;/\*\*

*  Created by wufei on 2018/12/10.  
    \*/

import com.wf.springdemo.locktest.redislock.RedisLock;

import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;

/\*\*

*  @author wufei
 *  @create 2018-12-10 9:12  
    \*\*/  
    public class Main \{  
    //模拟两个用户同时抢订单  
    public static void main(String\[\] args) \{  
    Thread user1 = new Thread(new UserThread(),“user1”);  
    Thread user2 = new Thread(new UserThread(),“user2”);  
    user1.start();  
    user2.start();  
    \}  
    //public static Lock lock = new ReentrantLock();  
    public static Lock lock = new RedisLock();  
    static class UserThread implements Runnable\{  
    @Override  
    public void run() \{  
    new Order().createOrder();  
    lock.lock();  
    Boolean result = new Stock().reduceStock();  
    lock.unlock();  
    if(result)\{  
    System.out.println(Thread.currentThread().getName() + " 减库存成功");  
    new Pay().pay();  
    \}else\{  
    System.out.println(Thread.currentThread().getName()+" 减库存失败");  
    \}  
    \}  
    \}  
    \}

package com.wf.springdemo.locktest.redislock;/\*\*

*  Created by wufei on 2018/12/10.  
    \*/

import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisCluster;

import java.util.Collections;  
import java.util.concurrent.TimeUnit;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;

/\*\*

*  @author wufei
 *  @create 2018-12-10 9:30  
    \*\*/  
    public class RedisLock implements Lock \{  
    private static String LOCK\_NAME = “redis\_lock”;  
    private static String REQUEST\_ID = “123456”;
    
    ThreadLocal jedis = new ThreadLocal();
    
    //加锁  
    @Override  
    public void lock() \{  
    init();  
    if(tryLock())\{//如果没有锁则加锁  
    //如果某个应用节点挂了，不能释放锁了也就是不能进入unlock（）方法了，这个情况怎么办呢？设置过期时间  
    // jedis.set(LOCK\_NAME,REQUEST\_ID);  
    // jedis.expire(LOCK\_NAME,3000);//设置过期时间  
    //但是这个时间不是原子性，执行到jedis.set方法了，但是应用挂了，没有执行jedis.expire，所有还会导致无法释放锁。  
    //怎么设置原子性呢。  
    jedis.get().set(LOCK\_NAME,REQUEST\_ID,“NX”,“PX”,3000);  
    \}  
    \}
    
    /\*\*
    
     *  获取锁 true 没有锁，false 有锁
     *  @return  
        \*/  
        @Override  
        public boolean tryLock() \{  
        //不停的获取锁  
        while (true)\{  
        //获取锁，怎样保证原子性呢 使用setnx方法  
        //key不存在返回1，存在返回0  
        //String lock = jedis.get(LOCK\_NAME);  
        Long lock = jedis.get().setnx(LOCK\_NAME,REQUEST\_ID);  
        if(lock ==1)\{  
        return true;  
        \}  
        \}  
        \}
    
    /\*\*
    
     *  释放锁  
        \*/  
        @Override  
        public void unlock() \{  
        //释放自己设置的锁，  
        // String value = jedis.get().get(LOCK\_NAME);  
        // if(REQUEST\_ID.equals(value))\{  
        // jedis.get().del(LOCK\_NAME);  
        // \}  
        //原子性 使用lua  
        // String script = “if redis.call(‘get’,KEYS\[1\]==ARGV\[1\]) then return redis.call(‘del’,KEYS\[1\]) else return 0 end”;  
        // jedis.get().eval(script, Collections.singletonList(LOCK\_NAME),Collections.singletonList(REQUEST\_ID));
        
        //lua script  
        String script = “if redis.call(‘get’, KEYS\[1\]) == ARGV\[1\] then return redis.call(‘del’, KEYS\[1\]) else return 0 end”;  
        Object result = jedis.get().eval(script, Collections.singletonList(LOCK\_NAME), Collections.singletonList(REQUEST\_ID));
    
    \}
    
    private void init()\{  
    if(jedis.get() == null)\{  
    jedis.set(new Jedis(“localhost”));  
    \}  
    \}
    
    @Override  
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException \{  
    return false;  
    \}  
    @Override  
    public void lockInterruptibly() throws InterruptedException \{
    
    \}
    
    @Override  
    public Condition newCondition() \{  
    return null;  
    \}  
    \}

zk分布式锁实现