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

redis> EXISTS job        # job 不存在
(integer) 0

redis> SETNX job "programmer"  # job 設置成功
(integer) 1

redis> SETNX job "code-farmer"  # 嘗試覆蓋 job ，失敗
(integer) 0

redis> GET job          # 沒有被覆蓋
"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;

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

  /**
   * 鎖等待時間，防止線程饑餓
   */
  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.
   * 實現思路: 主要是使用了redis 的setnx命令,緩存了鎖.
   * reids緩存的key是鎖的key,所有的共享, value是鎖的到期時間(注意:這里把過期時間放在value了,沒有時間上設置其超時時間)
   * 執行過程:
   * 1.通過setnx嘗試設置某個key的值,成功(當前沒有這個鎖)則返回,成功獲得鎖
   * 2.鎖已經存在則獲取鎖的到期時間,和當前時間比較,超時的話,則設置新的值
   *
   * @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); //鎖到期時間
      if (this.setNX(lockKey, expiresStr)) {
        // lock acquired
        locked = true;
        return true;
      }

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

        String oldValueStr = this.getSet(lockKey, expiresStr);
        //獲取上一個鎖到期時間，并設置現在的鎖到期時間，
        //只有一個線程才能獲取上一個線上的設置時間，因為jedis.getSet是同步的
        if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
          //防止誤刪（覆蓋，因為key是相同的）了他人的鎖——這里達不到效果，這里值會被覆蓋，但是因為什么相差了很少的時間，所以可以接受

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

      /*
        延遲100 毫秒, 這里使用隨機時間可能會好一點,可以防止饑餓進程的出現,即,當同時到達多個進程,
        只會有一個進程獲得鎖,其他的都用同樣的頻率進行嘗試,后面有來了一些進行,也以同樣的頻率申請鎖,這將可能導致前面來的鎖得不到滿足.
        使用隨機的等待時間可以一定程度上保證公平性
       */
      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 {
      //為了讓分布式鎖的算法更穩鍵些，持有鎖的客戶端在解鎖之前應該再檢查一次自己的鎖是否已經超時，再去做DEL操作，因為可能客戶端因為某個耗時的操作而掛起，
      //操作完的時候鎖因為超時已經被別人獲得，這時就不必解鎖了。 ————這里沒有做
      lock.unlock();
    }

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