余量扣除，即在高并发，大用户下，每个用户的余量数据频繁发生变化。例如：12306的某车次票的余量，商品库存，短信余量账本等。
针对，此类频繁发生修改的原子类余量对象，采用mysql,oracle等数据，一定会存在操作瓶颈。本文拟采用内存的办法实现，使用redis+Redisson客户端完成。当然，或许可以采用mangodb这类no-sql数据库。
Redisson客户端
https://github.com/mrniko/redisson/wiki
实现redis分布锁的客户端开源项目，redission支持4中连接redis方式，分别为单机，主从， Sentinel ， Cluster 集群，并提供以下类库
1.AtomicLong原子操作
2.分布式List
3.分布式Set
4.分布式Map
5.分布式Queue,
6.分布式SortedSet,
7.分布式ConcureentMap
8.分布式Lock
9.分布式CountDownLatch
10. 分布式Publish / Subscribe, HyperLogLog等
余量扣除代码片段
resources/redis.properties
#redis部署模式 SingleHost 1 MasterSlave 2 Sentinel 3 Cluster 4 redis.deploymentModel=2 redis.hosts=192.168.161.73:6379,192.168.161.129:6379 redis.masterName=mymaster redis.masteAddress=192.168.161.73:6379
RedissonClient
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
import java.util.concurrent.Future;
import org.redisson.Config;
import org.redisson.Redisson;
import org.redisson.connection.RandomLoadBalancer;
import org.redisson.core.RAtomicLong;
import org.redisson.core.RMap;
/**
*分布式锁客户端
* @author
*
*/
public class RedissonClient {
private static RedissonClient instance;
private RedissonClient(String filename) throws FileNotFoundException, IOException{
init(filename);
}
public static synchronized RedissonClient getInstance(String filename){
if(instance==null){
try {
instance=new RedissonClient(filename);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return instance;
}
public static void main(String[] args){
RedissonClient client= RedissonClient.getInstance("resources/redis.properties");
Redisson redisson=client.getSingleClient("ip:6379");
/*
RMap<String, String> map = redisson.getMap("anyMap");
String prevObject = map.put("123", new String());
String currentObject = map.putIfAbsent("323", new String());
String obj = map.remove("123");
map.fastPut("321", new String());
map.fastRemove("321");
Future<String> putAsyncFuture = map.putAsync("321");
Future<Void> fastPutAsyncFuture = map.fastPutAsync("321");
map.fastPutAsync("321", new String());
map.fastRemoveAsync("321");
redisson.shutdown();
*/
/**
* Distributed Object storage example
* Redisson redisson = Redisson.create();
RBucket<AnyObject> bucket = redisson.getBucket("anyObject");
bucket.set(new AnyObject());
bucket.setAsync(new AnyObject());
AnyObject obj = bucket.get();
redisson.shutdown();
*/
/**Distributed Set example
Redisson redisson = Redisson.create();
RSet<SomeObject> set = redisson.getSet("anySet");
set.add(new SomeObject());
set.remove(new SomeObject());
set.addAsync(new SomeObject());
redisson.shutdown();
**/
final RAtomicLong atomicLong = redisson.getAtomicLong("anyAtomicLong");
//atomicLong.set(1000);//初始化余量为1000，可以通过redis linux客户端设置1000
for(int i=0;i<2000;i++){//开始扣减余量，每次扣1.共计扣2000次。
new Runnable(){
@Override
public void run() {
try {
Thread.currentThread().sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(atomicLong.get()==0) {//当余量为0时，系统提示余量不够并退出
System.out.println(" error less than 0");
return ;
}
long r=atomicLong.decrementAndGet();
System.out.println("get "+r);
}
}.run();;
}
}
private static Redisson redisson=null;
public Redisson getClient(){
return redisson;
}
public void init(String filename) throws FileNotFoundException, IOException
{
//RedissonClient client=new RedissonClient();
PropertyReader propReader=PropertyReader.getInstance(filename);
Properties props=propReader.getProperties(filename);
String masterName=props.getProperty("redis.masterName");
String masteAddress=props.getProperty("redis.masteAddress");
int deployment_model=Integer.valueOf(props.getProperty("redis.deploymentModel")).intValue();
String hosts=props.getProperty("redis.hosts");
//redis部署模式 SingleHost 1 MasterSlave 2 Sentinel 3 Cluster 4
switch(deployment_model){
case 1:
redisson=getSingleClient(hosts);//单机
break;
case 2:
redisson=getMasterSlaveClient(masteAddress,hosts);
break;
case 3:
redisson=getSentinelClient(masterName,hosts);
break;
case 4:
redisson=getClusterClient(hosts);
break;
}
}
public Redisson getSingleClient(String host){
//Single server connection:
// connects to default Redis server 127.0.0.1:6379
//edisson redisson = Redisson.create();
// connects to single Redis server via Config
Config config = new Config();
config.useSingleServer()
.setAddress(host)
.setConnectionPoolSize(1000)
;
Redisson redisson = Redisson.create(config);
return redisson;
}
//Master/Slave servers connection:
public Redisson getMasterSlaveClient(String add,String hosts){
Config config = new Config();
String[] hostarr=hosts.split(",");
config.useMasterSlaveConnection()
.setMasterAddress(add)
.setLoadBalancer(new RandomLoadBalancer()) // RoundRobinLoadBalancer used by default
.addSlaveAddress(hostarr)
.setMasterConnectionPoolSize(10000)
.setSlaveConnectionPoolSize(10000);
Redisson redisson = Redisson.create(config);
return redisson;
}
//Sentinel servers connection:
public Redisson getSentinelClient(String masterName,String hosts){
String[] hostarr=hosts.split(",");
Config config = new Config();
config.useSentinelConnection()
.setMasterName(masterName)
.addSentinelAddress(hostarr)
.setMasterConnectionPoolSize(10000)
.setSlaveConnectionPoolSize(10000);
Redisson redisson = Redisson.create(config);
return redisson;
}
//Cluster nodes connections:
public Redisson getClusterClient(String hosts){
Config config = new Config();
config.useClusterServers()
.setScanInterval(2000) // sets cluster state scan interval
.addNodeAddress("127.0.0.1:7000", "127.0.0.1:7001")
.setMasterConnectionPoolSize(10000)
.setSlaveConnectionPoolSize(10000);
Redisson redisson = Redisson.create(config);
return redisson;
}
}
余量扣除代码片段2，扣除任意数值。
/**
* 扣取现金账本
* @param actid 账户id
* @return
* @throws FileNotFoundException
* @throws IOException
* @throws InterruptedException
*/
private boolean deductCashAccount(String actid,int amount) throws FileNotFoundException, IOException, InterruptedException{
/**扣余额直接操作redis缓存数据库，key由账户ID，-字符，字符串balance组成*/
long start=System.currentTimeMillis();
if(redisson==null) {
logger.error("Redisson is NULL");
return false;
}
String key="CASH_"+actid;
String lock_point="LOCK_CASH_"+actid;
RLock lock=redisson.getLock(lock_point);//获取账户锁对象
logger.info("get lock "+lock_point);
boolean locked=lock.tryLock(10,60, TimeUnit.SECONDS);//尝试锁住账户对象,waitTime第一个参数获取锁超时时间30毫秒,leaseTime第二参数,锁自动释放时间
if(!locked) {
logger.info("cann't get lock ,id="+actid);
return false;
}
//lock.lock();
logger.info("get lock "+lock_point+" ok");
RBucket<Integer> atomicbalance = redisson.getBucket(key);//获取原子余量
boolean result_flag=true;
if(atomicbalance.get()==0) {
logger.error(" error ,balance less than or equal to 0");
result_flag=false;
}
else{
atomicbalance.set(atomicbalance.get().intValue()-amount);//扣除余量
logger.info("balance is "+atomicbalance.get());
result_flag=true;
}
lock.unlock();//解锁
logger.info("debut cash , cost time:"+(System.currentTimeMillis()-start));
return result_flag;
}
实验结论：
本人在一项目中，使用以上两个分布式锁对象，进行了ab压力测试。设置初始余量，将以前代码片，发布为http api服务,ab多线程压力测试扣除余量操作，最终扣除的余量正确。
相关推荐
自己封装redisson方法，同时通过注解的方式加入redis分布式事务锁，可靠。
现在很多项目单机版已经不满足了，分布式变得越受欢迎，同时也带来很多问题，分布式锁也变得没那么容易实现，分享一个redis分布式锁工具类，里面的加锁采用lua脚本（脚本比较简单，采用java代码实现，无须外部调用...
SpringBoot基于redis的分布式锁,有word使用文档,根据文档配置即可使用
主要介绍了Java基于redis实现分布式锁代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
本资源为一步一步实现redis分布式锁的demo，利用redis实现高可用的分布式锁，规避各种坑、坑、坑！
redis实现分布式锁,自旋式加锁,lua原子性解锁
redis分布式锁，包含单服务器上锁解锁情况，和分布式上锁解锁情况，全部封装在类里，有需要可以下载，希望可以帮助到你。
Java开发基于SpringBoot+WebSocket+Redis分布式即时通讯群聊系统。一个基于Spring Boot + WebSocket + Redis，可快速开发的分布式即时通讯群聊系统。适用于直播间聊天、游戏内聊天、客服聊天等临时性群聊场景。 ...
C++的redis的API、 需要boost库、可直接加入工程目录编译
redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现 redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现
redlock-py, 在 python 中，Redis分布式锁 redlock - python 中的分布式锁这个 python 库实现了基于redis的分布式锁管理器算法( ) 。要创建锁定管理器：dlm = Redlock([{"host":"localhost","port":
用注解实现redis分布式锁，防止短时间内重复请求，尤其对于请求耗时较长的方法,希望对大家有帮助
本篇内容主要讲解的是redis分布式锁，这个在各⼤⼚⾯试⼏乎都是必备的，下⾯结合模拟抢单的场景来使⽤她；本篇不涉及到的 redis环境搭建，快速搭建个⼈测试环境，这⾥建议使⽤docker；
Redis分布式锁实现Redisson 15问.doc
redis分布式锁的工具类，采用的是Lua代码的方式，保证了Java执行方法的原子性。
自己整理的如何利用redis实现分布式锁，redis实现分布式锁看这一篇绝对够。
SpringBoot实现的Redis分布式锁代码示例
redis分布式锁带方法名和过期时间,如果不传方法名自动获取改方法名做key,使锁的粒度到方法级别,释放锁的时间可以根据自己的需要自定义,默认5s,为了解决超大方法执行时间太长,还没有执行完,锁就被释放掉的问题.
用Redis实现分布式锁的简易教程，在ppt中附有代码解析
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标: 理解redis分布式锁的应用场景 掌握redis分布式锁的实现原理 掌握redis分布式锁在微服务项目中的应用 掌握...