redis和redission分布式锁原理及区别说明

select * from u_car where car_id = 10;

update u_car set status = 2，version = version +1 where car_id = 10 and version = 1

	public boolean lock(string key, v v, int expiretime){
           //获取锁
           //在redis早期版本中，设置key和key的存活时间是分开的，设置key成功，但是设置存活时间时服务宕机，那么你的key就永远不会过期，有bug
           //后来redis将加锁和设置时间用同一个命令
           //这里是重点，redis.setnx(key，value,time)方法是原子性的，设置key成功说明锁车成功，如果失败说明该车被别人租了
         boolean b = false;
         try {
         	b = redis.setnx(key, v, expiretime);
         } catch (exception e) {
        	log.error(e.getmessage(), e);
    	 }
    	 return b;
    }
    public boolean unlock(string key){
        return redis.delete(key);
    }
}

//引入依赖
<dependency>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-starter-data-redis</artifactid>
        </dependency>
        <dependency>
            <groupid>org.redisson</groupid>
            <artifactid>redisson-spring-boot-starter</artifactid>
            <version>3.10.6</version>
        </dependency>

spring:  
    redis:
        host: 127.0.0.1
        port: 6379
        password: 

@configuration
public class redisconfig {
    @value("${spring.redis.host}")
    private string host;
 
    @bean(name = {"redistemplate", "stringredistemplate"})
    public stringredistemplate stringredistemplate(redisconnectionfactory factory) {
        stringredistemplate redistemplate = new stringredistemplate();
        redistemplate.setconnectionfactory(factory);
        return redistemplate;
    }
 
    @bean
    public redisson redisson() {
        config config = new config();
        config.usesingleserver().setaddress("redis://" + host + ":6379");
        return (redisson) redisson.create(config);
    }
 
}

private logger log = loggerfactory.getlogger(getclass());
@resource
private redisson redisson;
//加锁
public boolean lock(string key,long waittime,long leasetime){
	boolean  b = false;
	try {
        rlock rlock = redisson.getlock(key);
        //说下参数 waittime：锁的存活时间 leasetime：锁的延长时间 后面的参数是单位
        b = rlock.trylock(waittime,leasetime,timeunit.seconds);
      } catch (exception e) {
         log.error(e.getmessage(), e);
      } 
    }
    return b;
}
//释放锁
public void unlock(string key){
	try {
		rlock rlock = redisson.getlock(key);
		if(null!=lock){
			lock.unlock();
			lock.forceunlock();
			filelog.info("unlock succesed");
    	}
    } catch (exception e) {
        filelog.error(e.getmessage(), e);
    }
}

public boolean trylock(long waittime, long leasetime, timeunit unit) throws interruptedexception {
        long time = unit.tomillis(waittime);
        long current = system.currenttimemillis();
        long threadid = thread.currentthread().getid();
        //尝试获取锁，如果没取到锁，则获取锁的剩余超时时间
        long ttl = tryacquire(leasetime, unit, threadid);
        // lock acquired
        if (ttl == null) {
            return true;
        }
        //如果waittime已经超时了，就返回false
        time -= system.currenttimemillis() - current;
        if (time <= 0) {
            acquirefailed(threadid);
            return false;
        }
        
        current = system.currenttimemillis();
        rfuture<redissonlockentry> subscribefuture = subscribe(threadid);
        if (!await(subscribefuture, time, timeunit.milliseconds)) {
            if (!subscribefuture.cancel(false)) {
                subscribefuture.oncomplete((res, e) -> {
                    if (e == null) {
                        unsubscribe(subscribefuture, threadid);
                    }
                });
            }
            acquirefailed(threadid);
            return false;
        }
 
        try {
            time -= system.currenttimemillis() - current;
            if (time <= 0) {
                acquirefailed(threadid);
                return false;
            }
            //进入死循环，反复去调用tryacquire尝试获取锁，ttl为null时就是别的线程已经unlock了
            while (true) {
                long currenttime = system.currenttimemillis();
                ttl = tryacquire(leasetime, unit, threadid);
                // lock acquired
                if (ttl == null) {
                    return true;
                }
 
                time -= system.currenttimemillis() - currenttime;
                if (time <= 0) {
                    acquirefailed(threadid);
                    return false;
                }
 
                // waiting for message
                currenttime = system.currenttimemillis();
                if (ttl >= 0 && ttl < time) {
                    getentry(threadid).getlatch().tryacquire(ttl, timeunit.milliseconds);
                } else {
                    getentry(threadid).getlatch().tryacquire(time, timeunit.milliseconds);
                }
 
                time -= system.currenttimemillis() - currenttime;
                if (time <= 0) {
                    acquirefailed(threadid);
                    return false;
                }
            }
        } finally {
            unsubscribe(subscribefuture, threadid);
        }
//        return get(trylockasync(waittime, leasetime, unit));
    }