java基于jedisLock—redis分布式鎖實(shí)現(xiàn)示例代碼

long N=0L;
//N從redis獲取值
if(N<5){
N++；
//N寫(xiě)回redis
}

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          # 沒(méi)有被覆蓋
"programmer"

SETNX lock.foo <current Unix time + lock timeout + 1> 

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis distributed lock implementation.
 *
 * @author zhengcanrui
 */
public class RedisLock {

  private static Logger logger = LoggerFactory.getLogger(RedisLock.class);

  private RedisTemplate redisTemplate;

  private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 100;

  /**
   * Lock key path.
   */
  private String lockKey;

  /**
   * 鎖超時(shí)時(shí)間，防止線程在入鎖以后，無(wú)限的執(zhí)行等待
   */
  private int expireMsecs = 60 * 1000;

  /**
   * 鎖等待時(shí)間，防止線程饑餓
   */
  private int timeoutMsecs = 10 * 1000;

  private volatile boolean locked = false;

  /**
   * Detailed constructor with default acquire timeout 10000 msecs and lock expiration of 60000 msecs.
   *
   * @param lockKey lock key (ex. account:1, ...)
   */
  public RedisLock(RedisTemplate redisTemplate, String lockKey) {
    this.redisTemplate = redisTemplate;
    this.lockKey = lockKey + "_lock";
  }

  /**
   * Detailed constructor with default lock expiration of 60000 msecs.
   *
   */
  public RedisLock(RedisTemplate redisTemplate, String lockKey, int timeoutMsecs) {
    this(redisTemplate, lockKey);
    this.timeoutMsecs = timeoutMsecs;
  }

  /**
   * Detailed constructor.
   *
   */
  public RedisLock(RedisTemplate redisTemplate, String lockKey, int timeoutMsecs, int expireMsecs) {
    this(redisTemplate, lockKey, timeoutMsecs);
    this.expireMsecs = expireMsecs;
  }

  /**
   * @return lock key
   */
  public String getLockKey() {
    return lockKey;
  }

  private String get(final String key) {
    Object obj = null;
    try {
      obj = redisTemplate.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
          StringRedisSerializer serializer = new StringRedisSerializer();
          byte[] data = connection.get(serializer.serialize(key));
          connection.close();
          if (data == null) {
            return null;
          }
          return serializer.deserialize(data);
        }
      });
    } catch (Exception e) {
      logger.error("get redis error, key : {}", key);
    }
    return obj != null ? obj.toString() : null;
  }

  private boolean setNX(final String key, final String value) {
    Object obj = null;
    try {
      obj = redisTemplate.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
          StringRedisSerializer serializer = new StringRedisSerializer();
          Boolean success = connection.setNX(serializer.serialize(key), serializer.serialize(value));
          connection.close();
          return success;
        }
      });
    } catch (Exception e) {
      logger.error("setNX redis error, key : {}", key);
    }
    return obj != null ? (Boolean) obj : false;
  }

  private String getSet(final String key, final String value) {
    Object obj = null;
    try {
      obj = redisTemplate.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
          StringRedisSerializer serializer = new StringRedisSerializer();
          byte[] ret = connection.getSet(serializer.serialize(key), serializer.serialize(value));
          connection.close();
          return serializer.deserialize(ret);
        }
      });
    } catch (Exception e) {
      logger.error("setNX redis error, key : {}", key);
    }
    return obj != null ? (String) obj : null;
  }

  /**
   * 獲得 lock.
   * 實(shí)現(xiàn)思路: 主要是使用了redis 的setnx命令,緩存了鎖.
   * reids緩存的key是鎖的key,所有的共享, value是鎖的到期時(shí)間(注意:這里把過(guò)期時(shí)間放在value了,沒(méi)有時(shí)間上設(shè)置其超時(shí)時(shí)間)
   * 執(zhí)行過(guò)程:
   * 1.通過(guò)setnx嘗試設(shè)置某個(gè)key的值,成功(當(dāng)前沒(méi)有這個(gè)鎖)則返回,成功獲得鎖
   * 2.鎖已經(jīng)存在則獲取鎖的到期時(shí)間,和當(dāng)前時(shí)間比較,超時(shí)的話,則設(shè)置新的值
   *
   * @return true if lock is acquired, false acquire timeouted
   * @throws InterruptedException in case of thread interruption
   */
  public synchronized boolean lock() throws InterruptedException {
    int timeout = timeoutMsecs;
    while (timeout >= 0) {
      long expires = System.currentTimeMillis() + expireMsecs + 1;
      String expiresStr = String.valueOf(expires); //鎖到期時(shí)間
      if (this.setNX(lockKey, expiresStr)) {
        // lock acquired
        locked = true;
        return true;
      }

      String currentValueStr = this.get(lockKey); //redis里的時(shí)間
      if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
        //判斷是否為空，不為空的情況下，如果被其他線程設(shè)置了值，則第二個(gè)條件判斷是過(guò)不去的
        // lock is expired

        String oldValueStr = this.getSet(lockKey, expiresStr);
        //獲取上一個(gè)鎖到期時(shí)間，并設(shè)置現(xiàn)在的鎖到期時(shí)間，
        //只有一個(gè)線程才能獲取上一個(gè)線上的設(shè)置時(shí)間，因?yàn)閖edis.getSet是同步的
        if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
          //防止誤刪（覆蓋，因?yàn)閗ey是相同的）了他人的鎖——這里達(dá)不到效果，這里值會(huì)被覆蓋，但是因?yàn)槭裁聪嗖盍撕苌俚臅r(shí)間，所以可以接受

          //[分布式的情況下]:如過(guò)這個(gè)時(shí)候，多個(gè)線程恰好都到了這里，但是只有一個(gè)線程的設(shè)置值和當(dāng)前值相同，他才有權(quán)利獲取鎖
          // lock acquired
          locked = true;
          return true;
        }
      }
      timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;

      /*
        延遲100 毫秒, 這里使用隨機(jī)時(shí)間可能會(huì)好一點(diǎn),可以防止饑餓進(jìn)程的出現(xiàn),即,當(dāng)同時(shí)到達(dá)多個(gè)進(jìn)程,
        只會(huì)有一個(gè)進(jìn)程獲得鎖,其他的都用同樣的頻率進(jìn)行嘗試,后面有來(lái)了一些進(jìn)行,也以同樣的頻率申請(qǐng)鎖,這將可能導(dǎo)致前面來(lái)的鎖得不到滿足.
        使用隨機(jī)的等待時(shí)間可以一定程度上保證公平性
       */
      Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);

    }
    return false;
  }


  /**
   * Acqurired lock release.
   */
  public synchronized void unlock() {
    if (locked) {
      redisTemplate.delete(lockKey);
      locked = false;
    }
  }

}

 RedisLock lock = new RedisLock(redisTemplate, key, 10000, 20000);
 try {
      if(lock.lock()) {
          //需要加鎖的代碼
        }
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }finally {
      //為了讓分布式鎖的算法更穩(wěn)鍵些，持有鎖的客戶端在解鎖之前應(yīng)該再檢查一次自己的鎖是否已經(jīng)超時(shí)，再去做DEL操作，因?yàn)榭赡芸蛻舳艘驗(yàn)槟硞€(gè)耗時(shí)的操作而掛起，
      //操作完的時(shí)候鎖因?yàn)槌瑫r(shí)已經(jīng)被別人獲得，這時(shí)就不必解鎖了。 ————這里沒(méi)有做
      lock.unlock();
    }

lock(key, expireSec){
isSuccess = setnx key
if (isSuccess)
expire key expireSec
}