redis解决并发问题

用redis处理高并发是个很常见的方式,因为redis的访问效率很高(直接访问内存),一般我们会用来处理网站一瞬间的并发量。

那如果要使用redis来进行高并发问题的解决的话,应注意以下几点:

1、首先我们要先知道,我们在存储时,应使用redis的setnx方法,不应该使用set方法,因为setnx拥有原子操作命令(正确点说法应该是使用setnx,根据其属性可以保证共享资源的原子性操作),当资源锁存在不能设置值,则返回0,而当锁不存在,则设置锁,返回1; 但如果使用set方法,则会出现在高并发情况下,进程同时获取锁状态为null,同时设置,锁之间相互覆盖,但是俩进程仍在并发执行业务代码的情况。

2、为了防止死锁,我们不应直接使用jedis.setnx(lock, 1) 来进行简单的加锁,这样会导致当进程执行出现问题,锁未释放,则其他进程永远处于阻塞状态,出现死锁。 为了避免死锁,我们在加锁时带上时间戳,setnx(lock, 时间戳+超时时间),当发现锁超时了,便可以对锁进行重置,避免死锁。

接下来,实际操作!

设置锁:

//其中currentTimeMullis为当前时间、valideTime为超时时间,key为资源

//对该资源进行锁获取,如果存在锁则会返回false,不存在则设置值并返回true

boolean lock = redisService.setnx(key, currentTimeMullis+valideTime);

//如果不存在并设置了值,则可以直接返回,因为已经获取资源锁成功

//否则,则代表存在这个锁,则进行锁是否超时的判断。获取该资源的锁时间,用于判断是否超时了

String keyTime = redisService.get(key);

if((Long.valueOf(currentTimeMullis)-Long.valueOf(keyTime))>valideTime){

//该判断代表该资源锁已经超时,那么便进行资源锁的重置,也就是进行资源锁的重新设置(删除并重新设置)

//重新设置成功后也返回,因为获取锁成功,可以进行操作啦。

}

//如果以上操作都没有成功,则返回失败,代表获取锁失败,不可以进行操作。

释放锁:

当对资源处理结束后,则调用释放方法释放锁资源

(经提醒,我发现我这里少了个判断逻辑…)

//在删除前,应该先对该资源锁进行获取,判断值与此时释放锁的线程所携带的值是否相等,也就是我们上面创建时用的currentTimeMullis+valideTime。

String keyLockTime = redisService.get(key);

if(keyLockTime!=null&&keyLockTime.equals(currentTimeMullis+valideTime)){

//此时锁还由当前线程保持则释放锁

redisService.del(key);

}else{

//此时说明该资源锁被其他线程重置或释放,已不再拥有锁的释放权

//结束

}

具体的枷锁方法

package com.isatk.yn.module.common.service;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;

import com.github.rholder.retry.Attempt;
import com.github.rholder.retry.RetryListener;
import com.github.rholder.retry.Retryer;
import com.github.rholder.retry.RetryerBuilder;
import com.github.rholder.retry.StopStrategies;
import com.github.rholder.retry.WaitStrategies;
import com.google.common.base.Preconditions;
import com.isatk.yn.module.common.util.RedisLockComponentUtil;
import com.isatk.yn.util.AssertUtil;

import lombok.extern.slf4j.Slf4j;

/**
 * 
 * Redis分布式锁组件
 * 
 * @author: hlong
 */
@Slf4j
@Component
public class RedisLockComponent {
	private static final String SETNX_EXPIRE_TIME_SCRIPT = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then\n"
			+ "return redis.call('pexpire', KEYS[1], ARGV[2]);\n" + "end\n" + "return 0;";

	@Autowired
	public RedisTemplate<String, String> redisTemplate;

	public RedisLockComponent() {
	}

	public RedisTemplate<String, String> getRedisTemplate() {
		return redisTemplate;
	}

	/**
	 * 获取Redis分布式锁,支持可重入性 setIfAbsent()与expire()组全并不满足原子性,所以使用lua脚本保证原子性
	 */
	public void getLock(String redisKey, int keepLockTimeLenght, TimeUnit keepLockTimeUnit) throws Exception {
		AssertUtil.notNull(redisKey);
		String currentThreadQualifiedId = RedisLockComponentUtil.getCurrentThreadQualifiedId();
		String threadQualifiedId = (String) this.redisTemplate.opsForValue().get(redisKey);
		if (StringUtils.isNotEmpty(threadQualifiedId)
				&& StringUtils.equals(threadQualifiedId, currentThreadQualifiedId)) {
			return;
		}
		DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
		redisScript.setResultType(Long.class);
		redisScript.setScriptText(SETNX_EXPIRE_TIME_SCRIPT);
		List<String> keyList = Arrays.asList(redisKey);
		long time = TimeUnit.MILLISECONDS.convert(keepLockTimeLenght, keepLockTimeUnit);
		Long executeResult = (Long) this.redisTemplate.execute(redisScript, keyList, currentThreadQualifiedId, time);
		boolean isGettingRedisLockSuccessful = (executeResult != null && executeResult == 1);
		int retriedTimes = 0;
		while (!isGettingRedisLockSuccessful) {
			if (retriedTimes > 100) {
				log.warn("{} 获取redisKey循环次数超过100,当前次数:{}", redisKey, retriedTimes);
			}
			if (retriedTimes > 300) {
				throw new RuntimeException("获取redis key循环次数超过300");
			}
			Thread.sleep(210);
			isGettingRedisLockSuccessful = this.redisTemplate.opsForValue().setIfAbsent(redisKey,
					currentThreadQualifiedId);
			retriedTimes++;
		}

	}

	/**
	 * 获取Redis分布式锁,支持可重入性</br>
	 * 支持重试</br>
	 * setIfAbsent()与expire()组全并不满足原子性,所以使用lua脚本保证原子性
	 */
	public void getLockForRetry(String redisKey, int keepLockTimeLenght, TimeUnit keepLockTimeUnit) throws Exception {
		Preconditions.checkNotNull(redisKey);
		Preconditions.checkNotNull(keepLockTimeLenght);
		Preconditions.checkNotNull(keepLockTimeUnit);
		String currentThreadQualifiedId = RedisLockComponentUtil.getCurrentThreadQualifiedId();
		String cachedThreadQualifiedId = this.redisTemplate.opsForValue().get(redisKey);
		if (StringUtils.equals(cachedThreadQualifiedId, currentThreadQualifiedId)) {
			return;
		}
		DefaultRedisScript<Long> setNELuaJscript = new DefaultRedisScript<>();
		setNELuaJscript.setResultType(Long.class);
		setNELuaJscript.setScriptText(SETNX_EXPIRE_TIME_SCRIPT);
		List<String> redisKeyList = Arrays.asList(redisKey);
		long timeInMillis = TimeUnit.MILLISECONDS.convert(keepLockTimeLenght, keepLockTimeUnit);
		// 构造retryer
		RetryerBuilder<Boolean> retryerBuilder = RetryerBuilder.<Boolean> newBuilder()
				.withWaitStrategy(WaitStrategies.incrementingWait(1, TimeUnit.SECONDS, 5, TimeUnit.SECONDS));
		retryerBuilder.withStopStrategy(StopStrategies.stopAfterDelay(3, TimeUnit.MINUTES));
		retryerBuilder.withRetryListener(new RetryListener() {
			@Override
			public <Boolean> void onRetry(Attempt<Boolean> attempt) {
				log.info("第【{}】次重试,获取锁redisKey:{},结果:{},重试时间离第1次间隔为:{}(ms)!", attempt.getAttemptNumber(), redisKey,
						attempt.getResult(), attempt.getDelaySinceFirstAttempt());
			}
		});
		retryerBuilder.retryIfResult(getLockSuccessful -> !getLockSuccessful);
		Retryer<Boolean> retryer = retryerBuilder.build();
		retryer.call(new Callable<Boolean>() {
			@Override
			public Boolean call() throws Exception {
				Long executeResult = (Long) redisTemplate.execute(setNELuaJscript, redisKeyList,
						currentThreadQualifiedId, timeInMillis);
				boolean getLockSuccessful = (executeResult != null && executeResult == 1);
				return getLockSuccessful;
			}
		});
		log.info("最后一次,获取分布式锁redisKey:{}成功!", redisKey);
	}

	/**
	 * 
	 * 释放Redis锁
	 * 
	 * @param redisKey
	 *            void
	 */
	public void releaseLock(String redisKey) {
		if (StringUtils.isEmpty(redisKey)) {
			return;
		}
		this.redisTemplate.delete(redisKey);
	}

	/**
	 * 获取分布式锁
	 * 
	 * @param redisKey
	 * @param keepLockTimeLenght
	 * @param keepLockTimeUnit
	 * @return
	 */
	public boolean tryLock(String redisKey, int keepLockTimeLenght, TimeUnit keepLockTimeUnit) {
		AssertUtil.notNull(redisKey);
		AssertUtil.notNull(keepLockTimeLenght);
		AssertUtil.notNull(keepLockTimeUnit);
		String currentThreadQualifiedId = RedisLockComponentUtil.getCurrentThreadQualifiedId();
		String threadQualifiedId = (String) this.redisTemplate.opsForValue().get(redisKey);
		if (StringUtils.isNotEmpty(threadQualifiedId)
				&& StringUtils.equals(threadQualifiedId, currentThreadQualifiedId)) {
			return true;
		}
		DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
		redisScript.setResultType(Long.class);
		redisScript.setScriptText(SETNX_EXPIRE_TIME_SCRIPT);
		List<String> keyList = Arrays.asList(redisKey);
		long time = TimeUnit.MILLISECONDS.convert(keepLockTimeLenght, keepLockTimeUnit);
		Long executeResult = (Long) this.redisTemplate.execute(redisScript, keyList, currentThreadQualifiedId, time);
		boolean isGettingRedisLockSuccessful = (executeResult != null && executeResult == 1);
		if (!isGettingRedisLockSuccessful) {
			log.warn("redisKey:{},已经被占用,无法获取锁,不进行重试!", redisKey);
		}else{
			log.info("redisKey:{},获取锁成功", redisKey);
		}
		return isGettingRedisLockSuccessful;
	}
	public boolean trySetValue(String redisKey,String value, int keepLockTimeLenght, TimeUnit keepLockTimeUnit) {
		AssertUtil.notNull(redisKey);
		AssertUtil.notNull(value);
		AssertUtil.notNull(keepLockTimeLenght);
		AssertUtil.notNull(keepLockTimeUnit);
		DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
		redisScript.setResultType(Long.class);
		redisScript.setScriptText(SETNX_EXPIRE_TIME_SCRIPT);
		List<String> keyList = Arrays.asList(redisKey);
		long time = TimeUnit.MILLISECONDS.convert(keepLockTimeLenght, keepLockTimeUnit);
		Long executeResult = (Long) this.redisTemplate.execute(redisScript, keyList, value, time);
		boolean isGettingRedisLockSuccessful = (executeResult != null && executeResult == 1);
		if (!isGettingRedisLockSuccessful) {
			log.warn("redisKey:{},已经被占用,trySetValue失败,不进行重试!", redisKey);
		}else{
			log.info("redisKey:{},trySetValue成功,value:{}", redisKey,value);
		}
		return isGettingRedisLockSuccessful;
	}
	public String getLockOwner(String redisLockKey) {
		AssertUtil.notNull(redisLockKey);
		String threadQualifiedId = (String) this.redisTemplate.opsForValue().get(redisLockKey);
		return threadQualifiedId;
	}
 
}

 

 

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页