redis分布式内存锁：余量扣除示例

余量扣除，即在高并发，大用户下，每个用户的余量数据频繁发生变化。例如：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

 

Css代码  

1. #redis部署模式 SingleHost 1 MasterSlave 2 Sentinel 3  Cluster 4  
2. redis.deploymentModel=2  
3. redis.hosts=192.168.161.73:6379,192.168.161.129:6379  
4. redis.masterName=mymaster  
5. redis.masteAddress=192.168.161.73:6379  

 

RedissonClient 

 

Java代码  

1. import java.io.FileNotFoundException;  
2. import java.io.IOException;  
3. import java.util.Properties;  
4. import java.util.concurrent.Future;  
5.   
6. import org.redisson.Config;  
7. import org.redisson.Redisson;  
8. import org.redisson.connection.RandomLoadBalancer;  
9. import org.redisson.core.RAtomicLong;  
10. import org.redisson.core.RMap;  
11.   
12.   
13. /** 
14.  *分布式锁客户端 
15.  * @author  
16.  * 
17.  */  
18.   
19. public class RedissonClient {  
20.     private static RedissonClient instance;  
21.     private RedissonClient(String filename) throws FileNotFoundException, IOException{  
22.         init(filename);  
23.     }  
24.     public static synchronized RedissonClient getInstance(String filename){  
25.         if(instance==null){  
26.             try {  
27.                  instance=new  RedissonClient(filename);  
28.              } catch (FileNotFoundException e) {  
29.                 // TODO Auto-generated catch block  
30.                 e.printStackTrace();  
31.             } catch (IOException e) {  
32.                  // TODO Auto-generated catch block  
33.                  e.printStackTrace();  
34.             }  
35.         }  
36.         return instance;      
37.      }  
38.      public static void main(String[] args){  
39.         RedissonClient client= RedissonClient.getInstance("resources/redis.properties");  
40.         Redisson redisson=client.getSingleClient("ip:6379");  
41.         /* 
42.         RMap<String, String> map = redisson.getMap("anyMap"); 
43.         String prevObject = map.put("123", new String()); 
44.         String currentObject = map.putIfAbsent("323", new String()); 
45.         String obj = map.remove("123"); 
46.  
47.         map.fastPut("321", new String()); 
48.         map.fastRemove("321"); 
49.  
50.         Future<String> putAsyncFuture = map.putAsync("321"); 
51.         Future<Void> fastPutAsyncFuture = map.fastPutAsync("321"); 
52.  
53.         map.fastPutAsync("321", new String()); 
54.         map.fastRemoveAsync("321"); 
55.         redisson.shutdown(); 
56.         */  
57.           
58.         /** 
59.          * Distributed Object storage example 
60.          * Redisson redisson = Redisson.create(); 
61.  
62.             RBucket<AnyObject> bucket = redisson.getBucket("anyObject"); 
63.             bucket.set(new AnyObject()); 
64.             bucket.setAsync(new AnyObject()); 
65.             AnyObject obj = bucket.get(); 
66.              
67.             redisson.shutdown(); 
68.          */  
69.           
70.         /**Distributed Set example 
71.          Redisson redisson = Redisson.create(); 
72.  
73.         RSet<SomeObject> set = redisson.getSet("anySet"); 
74.         set.add(new SomeObject()); 
75.         set.remove(new SomeObject()); 
76.  
77.         set.addAsync(new SomeObject()); 
78.  
79.         redisson.shutdown(); 
80.         **/  
81.                 final RAtomicLong atomicLong = redisson.getAtomicLong("anyAtomicLong");  
82.         //atomicLong.set(1000);//初始化余量为1000，可以通过redis linux客户端设置1000  
83.         for(int i=0;i<2000;i++){//开始扣减余量，每次扣1.共计扣2000次。  
84.             new Runnable(){  
85.       
86.                 @Override  
87.                 public void run() {  
88.                       
89.                     try {  
90.                         Thread.currentThread().sleep(5);  
91.                     } catch (InterruptedException e) {  
92.                         e.printStackTrace();  
93.                     }  
94.                     if(atomicLong.get()==0) {//当余量为0时，系统提示余量不够并退出  
95.                         System.out.println(" error less than 0");  
96.                         return ;  
97.                     }  
98.                     long r=atomicLong.decrementAndGet();  
99.                     System.out.println("get "+r);  
100.                       
101.                 }  
102.                   
103.             }.run();;  
104.         }  
105.           
106.       
107.     }  
108.     private static Redisson redisson=null;  
109.     public Redisson  getClient(){  
110.         return  redisson;  
111.     }  
112.     public  void  init(String filename) throws FileNotFoundException, IOException  
113.     {  
114.         //RedissonClient client=new RedissonClient();  
115.         PropertyReader propReader=PropertyReader.getInstance(filename);  
116.         Properties props=propReader.getProperties(filename);  
117.         String masterName=props.getProperty("redis.masterName");  
118.         String masteAddress=props.getProperty("redis.masteAddress");  
119.         int deployment_model=Integer.valueOf(props.getProperty("redis.deploymentModel")).intValue();  
120.         String hosts=props.getProperty("redis.hosts");  
121.         //redis部署模式 SingleHost 1 MasterSlave 2 Sentinel 3  Cluster 4   
122.         switch(deployment_model){  
123.             case 1:  
124.                 redisson=getSingleClient(hosts);//单机  
125.                 break;  
126.             case 2:  
127.                 redisson=getMasterSlaveClient(masteAddress,hosts);  
128.                 break;  
129.             case 3:  
130.                 redisson=getSentinelClient(masterName,hosts);  
131.                 break;  
132.             case 4:  
133.                 redisson=getClusterClient(hosts);  
134.                 break;  
135.         }  
136.           
137.     }  
138.     public Redisson getSingleClient(String host){  
139.         //Single server connection:  
140.         // connects to default Redis server 127.0.0.1:6379  
141.         //edisson redisson = Redisson.create();  
142.           
143.         // connects to single Redis server via Config  
144.         Config config = new Config();  
145.             config.useSingleServer()  
146.                   .setAddress(host)  
147.                   .setConnectionPoolSize(1000)  
148.                   ;  
149.   
150.         Redisson redisson = Redisson.create(config);  
151.         return redisson;  
152.     }  
153.     //Master/Slave servers connection:  
154.     public Redisson getMasterSlaveClient(String add,String hosts){  
155.         Config config = new Config();  
156.         String[] hostarr=hosts.split(",");  
157.         config.useMasterSlaveConnection()  
158.             .setMasterAddress(add)  
159.             .setLoadBalancer(new RandomLoadBalancer()) // RoundRobinLoadBalancer used by default  
160.              
161.             .addSlaveAddress(hostarr)  
162.             .setMasterConnectionPoolSize(10000)  
163.             .setSlaveConnectionPoolSize(10000);  
164.   
165.         Redisson redisson = Redisson.create(config);  
166.         return redisson;  
167.     }  
168.     //Sentinel servers connection:  
169.     public Redisson getSentinelClient(String masterName,String hosts){  
170.         String[] hostarr=hosts.split(",");  
171.         Config config = new Config();  
172.         config.useSentinelConnection()  
173.             .setMasterName(masterName)  
174.             .addSentinelAddress(hostarr)  
175.             .setMasterConnectionPoolSize(10000)  
176.             .setSlaveConnectionPoolSize(10000);  
177.   
178.         Redisson redisson = Redisson.create(config);  
179.         return redisson;  
180.     }  
181.     //Cluster nodes connections:  
182.     public Redisson getClusterClient(String hosts){  
183.         Config config = new Config();  
184.         config.useClusterServers()  
185.             .setScanInterval(2000) // sets cluster state scan interval  
186.             .addNodeAddress("127.0.0.1:7000", "127.0.0.1:7001")  
187.             .setMasterConnectionPoolSize(10000)  
188.             .setSlaveConnectionPoolSize(10000);  
189.   
190.         Redisson redisson = Redisson.create(config);  
191.         return redisson;  
192.     }  
193. }  

 

 

余量扣除代码片段2，扣除任意数值。

 

 

Java代码  

1. /** 
2.      * 扣取现金账本 
3.      * @param actid  账户id 
4.       * @return 
5.       * @throws FileNotFoundException 
6.      * @throws IOException 
7.       * @throws InterruptedException  
8.      */  
9.     private boolean deductCashAccount(String actid,int amount) throws FileNotFoundException, IOException, InterruptedException{  
10.         /**扣余额直接操作redis缓存数据库，key由账户ID，-字符，字符串balance组成*/  
11.          long start=System.currentTimeMillis();  
12.          if(redisson==null) {  
13.              logger.error("Redisson is NULL");  
14.              return false;  
15.         }  
16.         String key="CASH_"+actid;  
17.         String lock_point="LOCK_CASH_"+actid;  
18.         RLock lock=redisson.getLock(lock_point);//获取账户锁对象  
19.         logger.info("get lock "+lock_point);  
20.         boolean locked=lock.tryLock(10,60, TimeUnit.SECONDS);//尝试锁住账户对象,waitTime第一个参数获取锁超时时间30毫秒,leaseTime第二参数,锁自动释放时间  
21.         if(!locked) {  
22.             logger.info("cann't get lock ,id="+actid);  
23.             return false;  
24.         }  
25.         //lock.lock();  
26.         logger.info("get lock "+lock_point+" ok");  
27.         RBucket<Integer> atomicbalance = redisson.getBucket(key);//获取原子余量  
28.         boolean result_flag=true;  
29.         if(atomicbalance.get()==0) {  
30.             logger.error(" error ,balance less than  or equal to 0");  
31.               
32.             result_flag=false;  
33.         }  
34.         else{  
35.             atomicbalance.set(atomicbalance.get().intValue()-amount);//扣除余量  
36.             logger.info("balance is  "+atomicbalance.get());  
37.             result_flag=true;  
38.         }  
39.         lock.unlock();//解锁  
40.          logger.info("debut cash , cost time:"+(System.currentTimeMillis()-start));  
41.         return result_flag;  
42.     }  

 

实验结论：

本人在一项目中，使用以上两个分布式锁对象，进行了ab压力测试。设置初始余量，将以前代码片，发布为http api服务,ab多线程压力测试扣除余量操作，最终扣除的余量正确。