redis> EXISTS job    # job 不存在
(integer) 0
redis> SETNX job "programmer" # job 設(shè)置成功
(integer) 1
redis> SETNX job "code-farmer" # 嘗試覆蓋 job ，失敗
(integer) 0
redis> GET job     # 沒有被覆蓋
"programmer"

redis> GETSET db mongodb # 沒有舊值，返回 nil
(nil)
redis> GET db
"mongodb"
redis> GETSET db redis  # 返回舊值 mongodb
"mongodb"
redis> GET db
"redis"

/**
 * 使用redis鎖來控制并發(fā)搶單
 * @author fuyuwei
 */
public class OrderBiz {
 public int createOrder(){
  // 下單之前的參數(shù)、合法性校驗這里就不在演示
  OrderLock<Boolean> orderLock = new RedisOrderLock<Boolean>("pro-12345678901");
  boolean isSyn = orderLock.isSyn(new OrderLockBiz<Boolean>(){
   @Override
   public Boolean createOrder() {
    // 省去創(chuàng)建訂單邏輯
    return null;
   }
  });
  if(!isSyn){
   BizLogger.info("創(chuàng)建訂單失敗");
  }
  return 0;
 }
}

public interface OrderLock<T> {
 public boolean isSyn(OrderLockBiz<T> orderBiz);

}

public interface OrderLockBiz<T> {
 public T createOrder();
}

public class RedisOrderLock<T> implements OrderLock<T> {

 // 鎖等待超時，防止線程饑餓，永遠沒有入鎖執(zhí)行代碼的機會 
 public static final long timeout = 10000;//ms

 // 鎖持有超時，防止線程在入鎖以后，無限的執(zhí)行下去，讓鎖無法釋放 
 public static final long expireMsecs = 10000;// ms

 public String lockKey = "orderLockKey";

 public Jedis jedis;

 private static volatile JedisPool jedisPool;

 public RedisOrderLock(String lockKey) {
  this.lockKey = lockKey;
 }
 /**
  * 初始化redis 
  * @return
  */
 public Jedis getInstance() {
  if(jedisPool == null) {
   synchronized(RedisOrderLock.class) {
    if(jedisPool == null) {
     JedisPoolConfig config = new JedisPoolConfig();
     config.setMaxIdle(100);
     jedisPool = new JedisPool(config,"localhost",6379, 3000,"test");
    }
   }
  }
  return jedisPool.getResource();
 }

 /**
  * 線程安全的業(yè)務(wù)邏輯處理
  */
 @Override
 public boolean isSyn(OrderLockBiz<T> orderBiz) {
  jedis = this.getInstance();
  try {
   // 獲取到鎖
   if(acquire(jedis)){
    // 執(zhí)行創(chuàng)建訂單邏輯
    orderBiz.createOrder();
   }else{
    BizLogger.info("waiting other thread creating");
   }
  } catch (Exception e) {
   BizLogger.error(e,"acquire lock failre");
  }finally{
   // 解鎖
   this.releaseLock(jedis);
  }
  return false;
 }

 /**
  * accqure lock
  * @param jedis
  * @return
  * @throws InterruptedException
  */
 public synchronized boolean acquire(Jedis jedis){
  boolean locked = false;
  while(timeout > 0){
   long expires = System.currentTimeMillis() + expireMsecs + 1;
   // 10秒之后鎖到期
   String expiresStr = String.valueOf(expires);
   // 獲取到鎖
   if(jedis.setnx(lockKey, expiresStr) == 1){
    locked = true;
    return locked;
   }
   // 沒有獲取到鎖
   String oldValue = jedis.get(lockKey);
   // expireMsecs（10秒）鎖的有效期內(nèi)無法進入if判斷，如果鎖超時了
   if(oldValue != null 
     && Long.parseLong(oldValue) < System.currentTimeMillis()){
    // 如果鎖超時重新設(shè)置
    String oldValue_ = jedis.getSet(lockKey, expiresStr);
    // 值相同說明是同一個線程的操作，獲取鎖成功
    if(Long.valueOf(oldValue_) == Long.valueOf(oldValue)){
     locked = true;
    }else{
     // 被其他線程搶先獲取鎖
     locked = false;
    }
   }
   // 鎖沒有超時，繼續(xù)等待
   return false;
  }
 }
 /**
  * 釋放鎖
  * @param jedis
  */
 public synchronized void releaseLock(Jedis jedis){
  try {
   long current = System.currentTimeMillis(); 
   // 避免刪除非自己獲取得到的鎖
   if (current < Long.valueOf(jedis.get(lockKey)))
    jedis.del(lockKey);
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   // 把用完的連接放到連接池匯中供其他線程調(diào)用
   jedisPool.returnResource(jedis);
  }
 }
}