redis 实现分布式锁以及测试

1.准备jar包

 compile group: 'redis.clients', name: 'jedis', version: '2.8.1'

 compile group: 'org.apache.commons', name: 'commons-pool2', version: '2.4.2'

 

2. 建立连接池：

package com.aebiz.redis;

import com.aebiz.bas.util.ftp.FtpResource;

 

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

 

public final class RedisUtil {

    

//    //Redis服务器IP

    private static String ADDR = "192.168.1.24";

//    

//    //Redis的端口号

    private static int PORT = 6379;

    

    //访问密码

    private static String AUTH = "admin";

    

    //可用连接实例的最大数目，默认值为8；

    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。

    private static int MAX_ACTIVE = 200;

    

    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。

    private static int MAX_IDLE = 50;

    

    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；

    private static int MAX_WAIT = 10000;

    

    private static int TIMEOUT = 10000;

    

    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

    private static boolean TEST_ON_BORROW = true;

    

    private static JedisPool jedisPool = null;

    

    /**

     * 初始化Redis连接池

     */

    static {

        try {

            JedisPoolConfig config = new JedisPoolConfig();

            //最大空闲连接数

            config.setMaxIdle(MAX_IDLE);

            config.setMaxTotal(MAX_ACTIVE);

          //  config.setMaxWait(MAX_WAIT);

            config.setTestOnBorrow(TEST_ON_BORROW);

            

//            config.setTestOnBorrow(false);

//            config.setTestOnReturn(false);

            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    

    /**

     * 获取Jedis实例

     * @return

     */

    public synchronized static Jedis getJedis() {

        try {

            if (jedisPool != null) {

                Jedis resource = jedisPool.getResource();

                return resource;

            } else {

            //重新连接

            repeatConn();

            Jedis resource = jedisPool.getResource();

                 return resource;

               

            }

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }

    

    /**

     * redis 3.0 以下

     * 释放jedis资源

     * @param jedis

     */

    public static void returnResource(final Jedis jedis) {

        if (jedis != null) {

            jedisPool.returnResource(jedis);

        }

    }

    

    //redis 3.0 以上

    public static void backResource(final Jedis jedis) {

        if (jedis != null && jedis.isConnected()) {

        jedis.close();

        }

    }

    

    

    public static void repeatConn(){

   

        JedisPoolConfig config = new JedisPoolConfig();

        config.setMaxIdle(MAX_IDLE);

        config.setMaxTotal(MAX_ACTIVE);

 

        config.setTestOnBorrow(TEST_ON_BORROW);

        jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT);

    }

}

 

 

3.客户端封装

 

package com.aebiz.redis;

 

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collection;

import java.util.List;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

 

import com.aebiz.auction.model.AuctionInfo;

import com.aebiz.pub.logs.PubLogs;

 

import net.sf.json.JSONArray;

import redis.clients.jedis.Jedis;

 

public class RedisClient {

 

private Jedis jedis;

 

public RedisClient() {

jedis = RedisUtil.getJedis();

}

 

public void close() {

if (null != jedis && jedis.isConnected()) {

jedis.close();

}

 

}

 

public long disLock(String key, String value) {

long result = 0;

StringBuffer lock = new StringBuffer();

result = jedis.setnx(key, value);

lock.append("key=").append(key);

lock.append(";lockstatus=").append(result);

// 获取锁后，设置锁失效时间

if (result > 0) {

// 设定锁存在30秒

long time = jedis.expire(key, 30);

lock.append(";lockTime=").append(time);

}

 

PubLogs.systemLogInfo(lock, null);

return result;

}

 

// 删除lock

public long delLock(String key) {

StringBuffer lock = new StringBuffer(key);

lock.append(";delLock");

PubLogs.systemLogInfo(lock, null);

return jedis.del(key);

}

 

public List<AuctionInfo> getList(String key) {

List<String> list = jedis.lrange(key, 0, 1);

if (null != list && list.size() > 0) {

 

@SuppressWarnings("unchecked")

Collection<AuctionInfo> cc = JSONArray.toCollection(JSONArray.fromObject(list.get(0)), AuctionInfo.class);

ArrayList<AuctionInfo> ll = new ArrayList<AuctionInfo>(cc);

return ll;

// return JSONArray.toList(JSONArray.fromObject(list.get(0)),

// AuctionInfo.class);

}

 

return null;

}

 

public void setList(String key, List<AuctionInfo> list) {

StringBuffer sbf = new StringBuffer(key);

sbf.append("key=").append(key);

// 对象转String

String strings = JSONArray.fromObject(list).toString();

sbf.append(";obj=").append(strings);

// 清楚缓存

long del = jedis.del(key);

sbf.append(";delstatus=").append(del);

// 放入缓存

long len = jedis.rpush(key, strings);

sbf.append(";len=").append(len);

 

PubLogs.systemLogInfo(sbf, null);

 

}

 

//模拟获取锁后，工作

public void waitLock(String key) {

int times = 0;//重试获取锁次数

while (times < 10) {

long res = disLock(key, "lock");

if (res > 0) {

System.out.println("处理业务信息");

times = 10;

delLock(key);

 

}else{

try {

Thread.sleep(300);

} catch (InterruptedException e) {

e.printStackTrace();

}

times++;

System.out.println("times---------------" + times);

 

}

}

 

System.out.println("-------------end=======");

 

}

 

//模拟插入数据，查询数据

public void test() {

long start = Calendar.getInstance().getTimeInMillis();

 

ExecutorService exe = Executors.newFixedThreadPool(80);

 

for (int j = 0; j < 20; j++) {

final int step = j;

exe.submit(new Runnable() {

@Override

public void run() {

RedisClient client = new RedisClient();

String key = "123456721ff";

 

List<AuctionInfo> list = new ArrayList<AuctionInfo>();

for (int i = 0; i < 6; i++) {

AuctionInfo auctionInfo = new AuctionInfo();

auctionInfo.setId("1" + i);

auctionInfo.setGoodsNo("goods" + i);

auctionInfo.setGoodsName("商品名称" + i);

list.add(auctionInfo);

}

 

client.setList(key, list);

List<AuctionInfo> result = client.getList(key);

for (AuctionInfo item : result) {

System.out.print(item.getId() + "--" + item.getGoodsNo());

}

System.out.println("===" + step);

client.close();

}

 

});

 

}

exe.shutdown();

long end = Calendar.getInstance().getTimeInMillis();

 

System.out.println("time:" + (end - start));

}

 

public static void main(String[] args) {

 

for(int i=0;i<6;i++){

RedisClient client = new RedisClient();

client.waitLock("qwe123");

client.close();

System.out.println("=============================="+i);

}

}

 

}