分布式系统核心要求：分布式锁实现之REDIS版本

最新推荐文章于 2023-03-19 15:52:11 发布
最新推荐文章于 2023-03-19 15:52:11 发布
阅读量584 收藏
点赞数
分类专栏： 分布式系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/boonya/article/details/105046535
版权

项目中使用到了redis如果这块没有严格要求，可以直接采用REDIS分布式锁。 在单体应用中直接通过线程notifyAll()实现线程之间协作，分布式中需要通过事件通知或消息发布订阅来实现。

目录

缺点与参考实现

Redis分布式锁核心命令

分布式锁使用粗放版本

SpringBoot RedisTemplate版本

Redis发布订阅解决分布式消息问题

频道和消息枚举

消息发布订阅消息监听类

消息发布线程

消息订阅线程

分布式锁初始化和消息发布实现

使用Arthas监控跟踪

watch

trace

tt

缺点与参考实现

优点：性能高，实现方便，在允许偶发的锁失效情况下，不影响系统正常使用建议使用缓存方式的锁。

缺点：通过锁超时机制不是十分可靠，当线程获得锁后，因处理时间很长导致锁超时，锁即失效。

参考实现： 

Java中wait、notify、notifyAll使用详解

分布式锁之Redis实现

Jedis分布式锁实现

Redis 发布订阅

Redis之发布订阅（Java）

Redis发布订阅模式

Redis分布式锁核心命令

SET resource_name my_random_value NX PX 30000

分布式锁使用粗放版本

Java代码如下：

@Component
public class RedisDistributedLock {

	private static Object lock = new Object();

	private static final String LOCK_SUCCESS = "OK";

	private static final String SET_IF_NOT_EXIST = "NX";

	private static final String SET_WITH_EXPIRE_TIME = "PX";

	private static final Long RELEASE_SUCCESS = 1L;

	/**
	 * 尝试获取分布式锁[记得关闭连接]
	 * 
	 * @param lockKey
	 *            锁
	 * @param requestId
	 *            请求标识
	 * @param expireTime
	 *            超期时间(ms)
	 * @return 是否获取成功
	 */
	public boolean tryGetDistributedLock(String lockKey, String requestId,int expireTime) {
		Jedis jedis = null;
		try {
			if (XHTSystemConfig.clusterModeForTomcat&&XHTSystemConfig.clusterRedisEnableWrite) {
				jedis = RedisNodeManagerUtil
						.getJedisFromPool(Constants.CLUSTER_ENABLE_WRITE_NAME);
			} else {
				jedis = RedisPool.getJedis();
			}
			// 获得锁
			synchronized(lock){
				String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST,	SET_WITH_EXPIRE_TIME, expireTime);
				if (LOCK_SUCCESS.equals(result)) {
					return true;
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != jedis) {
				jedis.close();
			}
		}
		return false;
	}

	/**
	 * 释放分布式锁[记得关闭连接]
	 * 
	 * @param lockKey
	 *            锁
	 * @param requestId
	 *            请求标识
	 * @return 是否释放成功
	 */
	public boolean releaseDistributedLock(String lockKey, String requestId) {
		Jedis jedis = null;
		try {
			if (XHTSystemConfig.clusterModeForTomcat&&XHTSystemConfig.clusterRedisEnableWrite) {
				jedis = RedisNodeManagerUtil
						.getJedisFromPool(Constants.CLUSTER_ENABLE_WRITE_NAME);
			} else {
				jedis = RedisPool.getJedis();
			}
			// 释放锁
			synchronized(lock){
				String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
				Object result = jedis.eval(script,
						Collections.singletonList(lockKey),
						Collections.singletonList(requestId));
				if (RELEASE_SUCCESS.equals(result)) {
					lock.notifyAll();
					return true;
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != jedis) {
				jedis.close();
			}
		}
		return false;
	}

	/**
	 * 分布式阻塞获取锁
	 * 
	 * @param key
	 */
	public String tryGetDistributedLockByBlocking(String lockKey, String requestId, int seconds) {
		boolean success = tryGetDistributedLock(lockKey, requestId, seconds*1000);
		if (success) {
			return requestId;// 获取成功直接返回
		}
		long waiting = seconds*1000;
		long end = System.currentTimeMillis() + waiting;
		while (!success && waiting >= 0) {
			// 同一个应用接收到通知会释放掉锁--分布式下其他节点暂时没实现通知（ZooKeeper可以实现事件监听，暂不引入）
			synchronized(lock){
				try {
					lock.wait(waiting);//被通知时释放锁解除等待
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			// 尝试获取锁
			success = tryGetDistributedLock(lockKey, requestId, seconds);
			waiting = end - System.currentTimeMillis();
		}
		if (success) {
			return requestId;
		} else {
			return Constants.CLUSTER_LOCK_FAILED;
		}
	}

}

SpringBoot RedisTemplate版本

try{
	lock = redisTemplate.opsForValue().setIfAbsent(lockKey, LOCK);
	logger.info("cancelCouponCode是否获取到锁："+lock);
	if (lock) {
		// TODO
		redisTemplate.expire(lockKey,1, TimeUnit.MINUTES); //成功设置过期时间
		return res;
	}else {
		logger.info("cancelCouponCode没有获取到锁，不执行任务!");
	}
}finally{
	if(lock){	
		redisTemplate.delete(lockKey);
		logger.info("cancelCouponCode任务结束，释放锁!");		
	}else{
		logger.info("cancelCouponCode没有获取到锁，无需释放锁!");
	}
}

Redis发布订阅解决分布式消息问题

分布式消息通知简单实现即可，集群每个节点都订阅相同的频道，消息发布都能接收到消息。因为单服务的线程通知对集群里面的其他服务是隔离的，所以这里采用Redis的消息发布订阅模式来实现事件的通知。

频道和消息枚举

public enum RedisChannel {

	/**
	 * channel：分布式锁通道
	 */
	DISTRIBUTE_LOCK("DISTRIBUTE_LOCK"),
	/**
	 * value：通知所有消息类型
	 */
	NOTIFYALL("NOTIFYALL");
	
	private String val="";
	
	private RedisChannel(String val){
		this.val = val;
	}

	@Override
	public String toString() {
		return val;
	}

}

消息发布订阅消息监听类

public class RedisPubSub extends JedisPubSub{
	
	private static Logger logger = Logger.getLogger(RedisPubSub.class);
	

	/**
	 * 消息处理(其他没有用的方法可以不重载)
	 */
	@Override
	public void onMessage(String channel, String message) {
		// TODO Auto-generated method stub
		super.onMessage(channel, message);
		// 处理频道消息
		switch(channel){
			// 分布式锁
			case "DISTRIBUTE_LOCK":
				if(message.equals(RedisChannel.NOTIFYALL)){
					synchronized(RedisDistributedLock.lock){
						//通知当前应用wait处理
						RedisDistributedLock.lock.notifyAll();
						logger.error(String.format("REDIS 消息：DISTRIBUTE_LOCK  NOTIFYALL={%s} ", RedisChannel.NOTIFYALL));
					}
				}
			    break;
			default:
				logger.error(String.format("REDIS 消息：channel= {%s}  message= {%s}", channel,message));
				break;
		}

	}

}

消息发布线程

public class Publisher extends Thread{
	
	private Jedis jedis;
	private String channel;
	private String message;
	
	public Publisher(Jedis jedis,String channel,String message){
		this.jedis = jedis;
		this.channel = channel;
		this.message = message;
	}

	@Override
	public void run() {
		try {
			//发布特定消息
			jedis.publish(channel, message);
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			jedis.close();
		}
	}

}

消息订阅线程

public class Subscriber extends Thread{
	
	private Jedis jedis;
	private JedisPubSub jedisPubSub;
	private String channel;
	
	public Subscriber(Jedis jedis,RedisPubSub jedisPubSub,String channel){
		this.jedis = jedis;
		this.jedisPubSub = jedisPubSub;
		this.channel = channel;
	}

	@Override
	public void run() {
		try {
			// 订阅特定消息
			jedis.subscribe(jedisPubSub, channel);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			jedis.close();
		}
	}
	
}

分布式锁初始化和消息发布实现

@Component
public class RedisDistributedLock {

	public static Object lock = new Object();

	private static final String LOCK_SUCCESS = "OK";

	private static final String SET_IF_NOT_EXIST = "NX";

	private static final String SET_WITH_EXPIRE_TIME = "PX";

	private static final Long RELEASE_SUCCESS = 1L;

	/**
	 * 尝试获取分布式锁[记得关闭连接]
	 * 
	 * @param lockKey
	 *            锁
	 * @param requestId
	 *            请求标识
	 * @param expireTime
	 *            超期时间(ms)
	 * @return 是否获取成功
	 */
	public boolean tryGetDistributedLock(String lockKey, String requestId,int expireTime) {
		Jedis jedis = null;
		try {
			if (XHTSystemConfig.clusterModeForTomcat&&XHTSystemConfig.clusterRedisEnableWrite) {
				jedis = RedisNodeManagerUtil
						.getJedisFromPool(Constants.CLUSTER_ENABLE_WRITE_NAME);
			} else {
				jedis = RedisPool.getJedis();
			}
			// 获得锁
			synchronized(lock){
				String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST,	SET_WITH_EXPIRE_TIME, expireTime);
				if (LOCK_SUCCESS.equals(result)) {
					return true;
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != jedis) {
				jedis.close();
			}
		}
		return false;
	}

	/**
	 * 释放分布式锁[记得关闭连接]
	 * 
	 * @param lockKey
	 *            锁
	 * @param requestId
	 *            请求标识
	 * @return 是否释放成功
	 */
	public boolean releaseDistributedLock(String lockKey, String requestId) {
		Jedis jedis = null;
		try {
			if (XHTSystemConfig.clusterModeForTomcat&&XHTSystemConfig.clusterRedisEnableWrite) {
				jedis = RedisNodeManagerUtil
						.getJedisFromPool(Constants.CLUSTER_ENABLE_WRITE_NAME);
			} else {
				jedis = RedisPool.getJedis();
			}
			// 释放锁
			synchronized(lock){
				String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
				Object result = jedis.eval(script,
						Collections.singletonList(lockKey),
						Collections.singletonList(requestId));
				if (RELEASE_SUCCESS.equals(result)) {
					
					lock.notifyAll();// 通知当前应用
					
					publishNotifyAllThread();// 通知集群其他节点
					
					return true;
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (null != jedis) {
				jedis.close();
			}
		}
		return false;
	}

	/**
	 * 分布式阻塞获取锁
	 * 
	 * @param key
	 */
	public String tryGetDistributedLockByBlocking(String lockKey, String requestId, int seconds) {
		boolean success = tryGetDistributedLock(lockKey, requestId, seconds*1000);
		if (success) {
			return requestId;// 获取成功直接返回
		}
		long waiting = seconds*1000;
		long end = System.currentTimeMillis() + waiting;
		while (!success && waiting >= 0) {
			// 同一个应用接收到通知会释放掉锁--分布式下其他节点暂时没实现通知（ZooKeeper可以实现事件监听，暂不引入）
			synchronized(lock){
				try {
					lock.wait(waiting);//被通知时释放锁解除等待
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			// 尝试获取锁
			success = tryGetDistributedLock(lockKey, requestId, seconds);
			waiting = end - System.currentTimeMillis();
		}
		if (success) {
			return requestId;
		} else {
			return Constants.CLUSTER_LOCK_FAILED;
		}
	}
	
	/**
	 * 初始化分布式锁消息通道订阅线程
	 */
	@PostConstruct
	private void initLockSubscribeThread(){
		Jedis jedis = null;
		// 用同步块解决并发初始化冲突问题
		synchronized(lock){
			if (XHTSystemConfig.clusterModeForTomcat&&XHTSystemConfig.clusterRedisEnableWrite) {
				jedis = RedisNodeManagerUtil
						.getJedisFromPool(Constants.CLUSTER_ENABLE_WRITE_NAME);
			} else {
				jedis = RedisPool.getJedis();
			}
			Subscriber sub = new Subscriber(jedis, new RedisPubSub(), RedisChannel.DISTRIBUTE_LOCK.toString());
			sub.start();
		}
	}
	
	/**
	 * 发布分布式锁释放通知消息线程
	 */
	private void publishNotifyAllThread(){
		Jedis jedis = null;
		if (XHTSystemConfig.clusterModeForTomcat&&XHTSystemConfig.clusterRedisEnableWrite) {
			jedis = RedisNodeManagerUtil
					.getJedisFromPool(Constants.CLUSTER_ENABLE_WRITE_NAME);
		} else {
			jedis = RedisPool.getJedis();
		}
		Publisher pub=new Publisher(jedis, RedisChannel.DISTRIBUTE_LOCK.toString(), RedisChannel.NOTIFYALL.toString());
		pub.start();
	}

}

使用Arthas监控跟踪

官网地址：https://arthas.aliyun.com/doc/index.html

watch

[arthas@18656]$ watch com.forestar.redis.RedisDistributedLock tryGetDistributedLock "{params,returnObj}" -x 2 -b -s -n 10
Press Q or Ctrl+C to abort.
Affect(class count: 1 , method count: 1) cost in 81 ms, listenerId: 7
method=com.forestar.redis.RedisDistributedLock.tryGetDistributedLock location=AtEnter
ts=2021-03-03 09:15:33; [cost=0.038707ms] result=@ArrayList[
    @Object[][
        @String[xht:application:hly-id-lock],
        @String[71f3965f-9429-4104-a475-03eacfd48dec],
        @Integer[5000],
    ],
    null,
]
method=com.forestar.redis.RedisDistributedLock.tryGetDistributedLock location=AtExit
ts=2021-03-03 09:15:33; [cost=2.3058954671954437E10ms] result=@ArrayList[
    @Object[][
        @String[xht:application:hly-id-lock],
        @String[71f3965f-9429-4104-a475-03eacfd48dec],
        @Integer[5000],
    ],
    @Boolean[true],
]
method=com.forestar.redis.RedisDistributedLock.tryGetDistributedLock location=AtEnter
ts=2021-03-03 09:15:43; [cost=0.016312ms] result=@ArrayList[
    @Object[][
        @String[xht:application:hly-id-lock],
        @String[7471d14f-4a60-4011-9623-d42b11e6d78c],
        @Integer[5000],
    ],
    null,
]
method=com.forestar.redis.RedisDistributedLock.tryGetDistributedLock location=AtExit
ts=2021-03-03 09:15:43; [cost=2.3058964472276306E10ms] result=@ArrayList[
    @Object[][
        @String[xht:application:hly-id-lock],
        @String[7471d14f-4a60-4011-9623-d42b11e6d78c],
        @Integer[5000],
    ],
    @Boolean[true],
]
method=com.forestar.redis.RedisDistributedLock.tryGetDistributedLock location=AtEnter
ts=2021-03-03 09:15:46; [cost=0.016448ms] result=@ArrayList[
    @Object[][
        @String[xht:application:hly-id-lock],
        @String[9132dcb6-b999-4fdc-902e-f834acd6a029],
        @Integer[5000],
    ],
    null,
]
method=com.forestar.redis.RedisDistributedLock.tryGetDistributedLock location=AtExit
ts=2021-03-03 09:15:46; [cost=2.3058967163121655E10ms] result=@ArrayList[
    @Object[][
        @String[xht:application:hly-id-lock],
        @String[9132dcb6-b999-4fdc-902e-f834acd6a029],
        @Integer[5000],
    ],
    @Boolean[false],
]
method=com.forestar.redis.RedisDistributedLock.tryGetDistributedLock location=AtEnter
ts=2021-03-03 09:15:51; [cost=0.011194ms] result=@ArrayList[
    @Object[][
        @String[xht:application:hly-id-lock],
        @String[9132dcb6-b999-4fdc-902e-f834acd6a029],
        @Integer[5],
    ],
    null,
]

trace

[arthas@18656]$ trace com.forestar.xht.hly.XHRYCtrl hly_add 
Press Q or Ctrl+C to abort.
Affect(class count: 2 , method count: 2) cost in 319 ms, listenerId: 10
`---ts=2021-03-03 09:33:07;thread_name=http-nio-8081-exec-7;id=27;is_daemon=true;priority=5;TCCL=org.apache.catalina.loader.WebappClassLoader@432cd66e
    `---[2.241784ms] com.forestar.xht.hly.XHRYCtrl$$EnhancerByCGLIB$$9eca3052:hly_add()
        `---[2.068124ms] net.sf.cglib.proxy.MethodInterceptor:intercept() #95
            `---[1.930108ms] com.forestar.xht.hly.XHRYCtrl:hly_add()
                +---[0.036573ms] data.common.util.StringUtils:IsNullOrEmpty() #183
                +---[0.01407ms] com.forestar.xht.util.Utils:getWorkSpace() #189
                +---[0.044448ms] com.forestar.xht.util.Utils:getMetadataWorkspace() #192
                +---[0.017292ms] data.metadata.IMetadataWorkspace:OpenTable() #95
                +---[0.00912ms] com.forestar.xht.util.Utils:getBaseDataService() #193
                +---[0.183323ms] com.alibaba.fastjson.JSONObject:parseObject() #196
                +---[0.011264ms] data.general.RowBase:<init>() #198
                +---[0.010371ms] data.general.RowBase:setCurrentObjects() #199
                +---[0.008256ms] com.forestar.core.session.SessionFactory:getSession() #201
                +---[0.010008ms] com.forestar.core.session.ISession:getTableSuffix() #95
                +---[0.037512ms] data.general.RowBase:getCurrentObjects() #202
                +---[0.010109ms] com.forestar.syscore.encrypt.MD5:<init>() #203
                +---[0.006698ms] data.general.RowBase:getCurrentObjects() #204
                +---[0.034949ms] com.forestar.syscore.encrypt.MD5:getMD5() #95
                +---[0.008434ms] data.general.RowBase:getCurrentObjects() #206
                +---[0.007273ms] data.general.QueryFilter:<init>() #207
                +---[0.024029ms] data.general.QueryFilter:setWhereString() #208
                `---[0.77195ms] com.forestar.redis.RedisDistributedLock:tryGetDistributedLockByBlocking() #215

`---ts=2021-03-03 09:33:16;thread_name=http-nio-8081-exec-35;id=52;is_daemon=true;priority=5;TCCL=org.apache.catalina.loader.WebappClassLoader@432cd66e
    `---[1.0833ms] com.forestar.xht.hly.XHRYCtrl$$EnhancerByCGLIB$$9eca3052:hly_add()
        `---[1.019633ms] net.sf.cglib.proxy.MethodInterceptor:intercept() #95
            `---[0.954022ms] com.forestar.xht.hly.XHRYCtrl:hly_add()
                +---[0.007426ms] data.common.util.StringUtils:IsNullOrEmpty() #183
                +---[0.038057ms] com.forestar.xht.util.Utils:getWorkSpace() #189
                +---[0.00616ms] com.forestar.xht.util.Utils:getMetadataWorkspace() #192
                +---[0.007478ms] data.metadata.IMetadataWorkspace:OpenTable() #95
                +---[0.007375ms] com.forestar.xht.util.Utils:getBaseDataService() #193
                +---[0.038762ms] com.alibaba.fastjson.JSONObject:parseObject() #196
                +---[0.005113ms] data.general.RowBase:<init>() #198
                +---[0.006275ms] data.general.RowBase:setCurrentObjects() #199
                +---[0.006229ms] com.forestar.core.session.SessionFactory:getSession() #201
                +---[0.006964ms] com.forestar.core.session.ISession:getTableSuffix() #95
                +---[0.004853ms] data.general.RowBase:getCurrentObjects() #202
                +---[0.005499ms] com.forestar.syscore.encrypt.MD5:<init>() #203
                +---[0.004376ms] data.general.RowBase:getCurrentObjects() #204
                +---[0.019182ms] com.forestar.syscore.encrypt.MD5:getMD5() #95
                +---[0.004806ms] data.general.RowBase:getCurrentObjects() #206
                +---[0.005104ms] data.general.QueryFilter:<init>() #207
                +---[0.004758ms] data.general.QueryFilter:setWhereString() #208
                `---[0.511894ms] com.forestar.redis.RedisDistributedLock:tryGetDistributedLockByBlocking() #215

`---ts=2021-03-03 09:33:25;thread_name=http-nio-8081-exec-15;id=2f;is_daemon=true;priority=5;TCCL=org.apache.catalina.loader.WebappClassLoader@432cd66e
    `---[0.95822ms] com.forestar.xht.hly.XHRYCtrl$$EnhancerByCGLIB$$9eca3052:hly_add()
        `---[0.920732ms] net.sf.cglib.proxy.MethodInterceptor:intercept() #95
            `---[0.866213ms] com.forestar.xht.hly.XHRYCtrl:hly_add()
                +---[0.007652ms] data.common.util.StringUtils:IsNullOrEmpty() #183
                +---[0.011245ms] com.forestar.xht.util.Utils:getWorkSpace() #189
                +---[0.005283ms] com.forestar.xht.util.Utils:getMetadataWorkspace() #192
                +---[0.007431ms] data.metadata.IMetadataWorkspace:OpenTable() #95
                +---[0.007284ms] com.forestar.xht.util.Utils:getBaseDataService() #193
                +---[0.039893ms] com.alibaba.fastjson.JSONObject:parseObject() #196
                +---[0.005045ms] data.general.RowBase:<init>() #198
                +---[0.004925ms] data.general.RowBase:setCurrentObjects() #199
                +---[0.005901ms] com.forestar.core.session.SessionFactory:getSession() #201
                +---[0.008045ms] com.forestar.core.session.ISession:getTableSuffix() #95
                +---[0.00491ms] data.general.RowBase:getCurrentObjects() #202
                +---[0.005447ms] com.forestar.syscore.encrypt.MD5:<init>() #203
                +---[0.004425ms] data.general.RowBase:getCurrentObjects() #204
                +---[0.017348ms] com.forestar.syscore.encrypt.MD5:getMD5() #95
                +---[0.004585ms] data.general.RowBase:getCurrentObjects() #206
                +---[0.004571ms] data.general.QueryFilter:<init>() #207
                +---[0.004564ms] data.general.QueryFilter:setWhereString() #208
                `---[0.431266ms] com.forestar.redis.RedisDistributedLock:tryGetDistributedLockByBlocking() #215

tt

获取类的静态字段、调用类的静态方法：https://arthas.aliyun.com/doc/tt.html

 

boonya
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis分布式锁的正确实现方法总结
09-08
Redis分布式锁是一种在分布式系统中实现锁机制的方法，通常用于协调多个服务实例之间的资源访问。在高并发的微服务架构中，分布式锁是解决数据一致性、防止并发问题的关键工具。本文将深入探讨基于Redis实现分布式锁...
Redis实现分布式锁的方法示例
09-09
分布式锁是一种在分布式系统中确保资源互斥访问的机制，特别是在多台服务器并行处理请求时，防止同一资源被多个客户端同时占用。Redis作为一个高性能的键值存储系统，常被用作实现分布式锁的工具。本文将深入探讨...
Redis 3.0.0正式版发布，全新的分布式高可用数据库
博客
04-02 314
Redis 3.0.0 正式版终于到来了！最重要的新特性是集群（Redis Cluster），提供Redis功能子集（比如不支持多数据库）的分布式、容错的实现（最多支持1000结点）。 Salvatore 'antirez' Sanfilippo在Google Groups里表示，这是Redis的重要时刻。“我相信今天的Redis 3.0.0将以某种方式完全改变Redis的面貌。”他强调，人...
12-Redis分布式【高性能、高并发、高可用】
wangyongxun1983的博客
10-03 150
RedisCluster是在Redis3.0的版本正式推出的，用来解决分布式的需求，同时也可以实现高可用。 01、架构 RedisCluster可以看成是由多个Redis实例组成的数据集合。客户端不需要关注数据的子集到底存储在哪个节点，只需要关注这个集合整体。 案例： 3主3从为例，节点之间两两交互，共享数据分片、节点状态等信息 02、搭建 https://gper.club/articles/7e7e7f7ff7g5egc7g6d 03、数据分布 如果是希望数据分布相对均匀的话，我们首
Redis中的分布式缓存--第二版本
qq_36382679的博客
09-08 67
Day07_08_分布式教程之分布式锁实现方案
一一哥
06-08 479
分布式锁实现方案 一. 常见的锁--线程锁/进程锁/分布式锁 线程锁:比如synchronize,主要用来给方法、代码块加锁.当某个方法或者代码块使用锁时,那么在同一时刻至多仅有有一个线程在执行该段代码.当有多个线程访问同一对象的加锁方法/代码块时,同一时间只有一个线程在执行,其余线程必须要等待当前线程执行完之后才能执行该代码段.但是,其余线程是可以访问该对象中的非加锁代码块的. ...
分布式锁介绍
qq_36969486的博客
03-12 193
基于redis的分布式锁实现 1.分布式锁介绍 　　在计算机系统中，锁作为一种控制并发的机制无处不在。 　　单机环境下，操作系统能够在进程或线程之间通过本地的锁来控制并发程序的行为。而在如今的大型复杂系统中，通常采用的是分布式架构提供服务。 　　分布式环境下，基于本地单机的锁无法控制分布式系统中分开部署客户端的并发行为，此时分布式锁就应运而生了。 一个可靠的分布式锁应该具备以下特性： ...
Redis Template实现分布式锁的实例代码
09-09
Redis 分布式锁是一种在分布式系统中实现锁的常见方法，其核心在于利用Redis的原子性操作来保证并发环境下的安全。在本例中，使用了`Redis Template`，它是Spring Data Redis提供的一个高级API，方便进行Redis的操作...
scala+redis实现分布式锁的示例代码
08-25
总的来说，通过Scala和Redis的组合，我们可以方便地实现一个分布式锁，用于控制分布式系统中的并发访问。上述示例代码提供了一个基本的实现框架，但在实际项目中，需要根据具体需求进行调整和优化。
谈谈Redis分布式锁的正确实现方法
09-09
Redis 分布式锁是一种在分布式系统中实现锁机制的关键技术，主要用于解决多节点间并发操作导致的数据一致性问题。本文将深入探讨Redis分布式锁的正确实现方法，以及如何避免潜在的问题。 首先，传统的基于`setnx`...
3、redis分布式锁的相关那些事儿
a1290123825的博客
10-31 363
目录 1、最简版redis分布式锁 2、基于SETNX+GETSET实现的redis分布式锁 3、基于SETNX实现的redis分布式锁 4、Redlock实现的redis分布式锁 5、关于锁续期和锁重入的问题 分布式锁我们能想到什么？ 从锁的本质说起，锁的意义便是锁定资源，限制资源在某个时间点操作权限；限制资源只需要在针对某个方法、代码块进行锁定标记，分布式锁和synchron...
redis实现分布式锁的用法
heihei_100的博客
06-15 1416
1.redis锁 import java.util.Collections; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import lombok.extern.slf4j.Slf4j; import redis...
分布式｜进入BAT必备指 使用Redis实现分布式锁
热门推荐
08-29 2万+
十三、Redis实现分布式锁 为什么要使用分布式锁？ 我们在多线程开发过程中，肯定没避免不了使用锁，jdk中也提供了大量的锁功能，但是我们为什么还要手动开发一个分布式锁呢，原因在于我们在传统项目中使用的锁实在同一个进程中的，他们能够相互访问到彼此的资源信息，但是在分布式中，每个项目都是跑在不同的进程中的，他们无法共享资源信息，所以就需要一个能够在不同进程之间进行“通信”的第三方来实现这个功能，那么redis其实就具备这种功能的。 redis实现分布式锁的原理 其实redis实现的原理主要就是某个线程现
redis应用系列一：分布式锁正确实现姿势
weixin_41882200的博客
07-30 300
实现分布式锁常见有三种实现方式： 基于数据库 基于缓存（redis）分布式锁， 基于 Zookeeper 实现分布式锁 以下是他们在可靠性、性能、复杂性三个维度的对比 评判维度 比较 评判维度 比较 可靠性 Zookeeper > 缓存 > 数据库 性能 缓存 > Zookeeper >= 数据库 复杂性 Zookeeper >= 缓存 > 数据库 由于 redis 高性能，在许多密集型的业务场景中是运用最多，因此以下介绍基于 redis
Arthas 是Alibaba开源的Java诊断工具
lovo1的专栏
09-17 406
Arthas是Alibaba开源的Java诊断工具，深受开发者喜爱。 当你遇到以下类似问题而束手无策时，Arthas可以帮助你解决： 这个类从哪个 jar 包加载的？为什么会报各种类相关的 Exception？ 我改的代码为什么没有执行到？难道是我没 commit？分支搞错了？ 遇到问题无法在线上 debug，难道只能通过加日志再重新发布吗？ 线上遇到某个用户的数据处理有问题，但线上同样无法 debug，线下无法重现！ 是否有一个全局视角来查看系统的运行...
arthas2--监控
中国华的博客
08-18 470
--观察所有成员变量的值 [arthas@14359]$ watch demo.MathGame primeFactors "target" -x 2 Press Q or Ctrl+C to abort. Affect(class count: 1 , method count: 1) cost in 101 ms, listenerId: 1 ts=2020-08-18 14:14:17; [cost=1.251937ms] result=@MathGame[ random=@Ra...
Arthas实践--获取分布式追踪的traceId
横云断岭的专栏
06-08 2748
ArthasArthas是Alibaba开源的Java诊断工具，深受开发者喜爱。Github：https://github.com/alibaba/arthas文档：https://al...
arthas 用法
06-05 647
java -jar arthas-boot.jar 启动 选择需要监控的pid编号 dashboard可以查看线程，内存，GC，以及Runtime信息 ID NAME GROUP PRIORITY STATE ...
Redis的版本选择与Linux下的安装（全网最细保姆级别教学）
舒一笑的博客
03-19 2378
Redis的版本选择与Linux下的安装
redis分布式锁redlock讲解
最新发布
07-14
Redis分布式锁是一种解决分布式系统并发控制的技术，其中redlock是一种常见的实现方式。它基于Redis的原子操作和特性，可以保证在分布式环境下实现互斥访问。 Redlock算法是由Redis作者Antirez在2016年提出的，它的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值