Redis 实现分布式锁

前言

在分布式系统中，为了保证数据的一致性和避免并发问题，我们经常需要使用分布式锁。而 Redis 是一个高性能的内存型数据库，也是一个常用的分布式锁实现方式。本文将介绍 Redis 实现分布式锁的原理、实现方式以及注意事项。

原理

Redis 实现分布式锁的原理是利用 Redis 单线程的特性和 SETNX 命令的原子性。SETNX 命令可以保证在多个客户端同时执行 SETNX 命令时，只有一个客户端能够成功地获取到锁。当一个客户端获取到锁后，其他客户端需要等待锁释放后才能再次尝试获取锁。

实现方式

1. 基本实现

下面是一个基本的分布式锁实现方式：

// www.javascriptcn.com code example
const redis = require('redis');
const client = redis.createClient();

function acquireLock(lockName, timeout) {
  return new Promise((resolve, reject) => {
    const key = `locks:${lockName}`;
    const value = new Date().getTime() + timeout + 1;
    client.setnx(key, value, (err, result) => {
      if (err) {
        reject(err);
      } else if (result === 1) {
        resolve();
      } else {
        client.get(key, (err, result) => {
          if (err) {
            reject(err);
          } else if (result && result < new Date().getTime()) {
            client.getset(key, value, (err, result) => {
              if (err) {
                reject(err);
              } else if (result === value) {
                resolve();
              } else {
                reject();
              }
            });
          } else {
            reject();
          }
        });
      }
    });
  });
}

function releaseLock(lockName) {
  const key = `locks:${lockName}`;
  client.del(key);
}

(async function() {
  try {
    await acquireLock('myLock', 5000);
    console.log('Lock acquired');
    // do something
  } catch (err) {
    console.error('Failed to acquire lock', err);
  } finally {
    releaseLock('myLock');
    console.log('Lock released');
  }
})();

上面的代码中，acquireLock 函数尝试获取名为 lockName 的锁，如果获取成功则返回 Promise.resolve()，否则等待一段时间后重试。timeout 参数指定等待时间，单位为毫秒。releaseLock 函数用于释放锁。

2. 可重入实现

上面的基本实现方式虽然可以保证互斥性，但是不能保证可重入性。如果一个线程已经持有了锁，此时再次尝试获取锁，应该直接返回成功而不是陷入死等。下面是一个可重入的实现方式：

// www.javascriptcn.com code example
const redis = require('redis');
const client = redis.createClient();

function acquireLock(lockName, timeout) {
  const key = `locks:${lockName}`;
  let retries = 0;

  function attempt() {
    return new Promise((resolve, reject) => {
      const value = `${process.pid}:${retries}:${new Date().getTime()}`;
      client.setnx(key, value, (err, result) => {
        if (err) {
          reject(err);
        } else if (result === 1) {
          resolve({
            value: value,
            retries: retries,
          });
        } else {
          client.get(key, (err, result) => {
            if (err) {
              reject(err);
            } else if (result.startsWith(`${process.pid}:`)) {
              retries++;
              setTimeout(() => {
                attempt().then(resolve).catch(reject);
              }, 10);
            } else {
              reject();
            }
          });
        }
      });
    });
  }

  return attempt().then((lock) => {
    return {
      lockName: lockName,
      value: lock.value,
      retries: lock.retries,
      release: () => releaseLock(lockName, lock.value),
    };
  });
}

function releaseLock(lockName, value) {
  const key = `locks:${lockName}`;
  client.get(key, (err, result) => {
    if (err) {
      console.error('Failed to release lock', err);
    } else if (result === value) {
      client.del(key);
    }
  });
}

(async function() {
  try {
    const lock = await acquireLock('myLock', 5000);
    console.log('Lock acquired', lock);
    const lock2 = await acquireLock('myLock', 5000);
    console.log('Lock re-acquired', lock2);
    lock2.release();
  } catch (err) {
    console.error('Failed to acquire lock', err);
  }
})();

上面的代码中，acquireLock 函数返回一个包含锁的信息和释放锁的方法的对象，这样可以方便地在使用锁的代码块中随时释放锁。releaseLock 函数只有当锁的值与当前进程持有的值相同时才会释放锁。

注意事项

1. 锁的过期时间应该设置为一个适当的值，以避免锁被长时间持有，造成系统性能问题。
2. 锁的名称应该具有唯一性，避免不同的锁名称冲突。
3. 在使用锁的代码块中应该尽量保持简短，避免锁的持有时间过长。
4. 在使用可重入锁的情况下，应该注意锁的重入次数，避免死等。

结语

本文介绍了 Redis 实现分布式锁的原理、实现方式以及注意事项。分布式锁是分布式系统中非常重要的一部分，掌握分布式锁的实现方式对于提高系统的性能和稳定性具有重要意义。

来源：JavaScript中文网 ，转载请注明来源 https://www.javascriptcn.com/post/67d53876a941bf71349a6a35