面试官：Redis 分布式锁如何实现，存在哪些问题？Redlock 算法的核心思想是什么？Redis 事务原理怎样，是否支持回滚

try{
  String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
  if ("OK".equals(result)) {
      return true;
  }
  return false;
} finally {
    unlock(lockKey);
}

if (jedis.setnx(lockKey, val) == 1) {
   jedis.expire(lockKey, timeout);
}

if (jedis.get(lockKey).equals(requestId)) {
    jedis.del(lockKey);
    return true;
}
return false;

try {
  Long start = System.currentTimeMillis();
  while(true) {
     String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
     if ("OK".equals(result)) {
        // do something
        return true;
     }
     long time = System.currentTimeMillis() - start;
      if (time>=timeout) {
          return false;
      }
      try {
          int randomSleepTime = 10 + random.nextInt(90);
          Thread.sleep(randomSleepTime);
      } catch (InterruptedException e) {
          e.printStackTrace();
      }
  }
} finally{
    unlock(lockKey,requestId);
}  
return false;

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
public class RedissonReentrantLockExample {
    public static void main(String[] args) {
        // 配置Redisson客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redissonClient = Redisson.create(config);
        // 获取可重入锁对象
        RLock lock = redissonClient.getLock("myLock");
        try {
            // 第一次加锁
            lock.lock();
            System.out.println("第1次加锁成功");
            // 执行需要同步的代码块
            // ...
            // 第二次加锁（同一线程）
            lock.lock();
            System.out.println("第2次加锁成功");
            // 执行需要同步的代码块
            // ...
            // 第一次释放锁
            lock.unlock();
            System.out.println("第1次释放锁");
            // 执行其他代码
            // ...
            // 第二次释放锁
            lock.unlock();
            System.out.println("第2次释放锁，锁被完全释放");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 确保在程序结束时关闭Redisson客户端
            redissonClient.shutdown();
        }
    }
}

import org.redisson.Redisson;
import org.redisson.api.RFairLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
public class RedissonFairLockExample {
    public static void main(String[] args) {
        // 配置Redisson客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redissonClient = Redisson.create(config);
        // 获取公平锁对象
        RFairLock fairLock = redissonClient.getFairLock("myFairLock");
        // 模拟多个线程竞争锁
        Runnable task = () -> {
            try {
                // 请求锁
                fairLock.lock();
                try {
                    // 获得锁后执行的代码
                    System.out.println(Thread.currentThread().getName() + " 获得了锁");
                    // 模拟任务执行时间
                    Thread.sleep(2000);
                } finally {
                    // 释放锁
                    fairLock.unlock();
                    System.out.println(Thread.currentThread().getName() + " 释放了锁");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                e.printStackTrace();
            }
        };
        // 创建并启动多个线程
        for (int i = 0; i < 5; i++) {
            new Thread(task, "Thread-" + i).start();
        }
        // 确保在程序结束时关闭Redisson客户端
        Runtime.getRuntime().addShutdownHook(new Thread(() -> redissonClient.shutdown()));
    }
}

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.api.RWLock;
import org.redisson.config.Config;
import java.util.concurrent.TimeUnit;
public class RedissonReadWriteLockExample {
    public static void main(String[] args) {
        // 配置Redisson客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        // 创建Redisson客户端
        RedissonClient redissonClient = Redisson.create(config);
        // 获取读写锁
        RWLock rwLock = redissonClient.getReadWriteLock("myReadWriteLock");
        // 读取操作示例
        new Thread(() -> {
            RLock readLock = rwLock.readLock();
            try {
                // 获取读锁
                readLock.lock();
                // 执行读取操作
                System.out.println("Read operation started");
                // 模拟读取操作耗时
                TimeUnit.SECONDS.sleep(2);
                System.out.println("Read operation completed");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 释放读锁
                readLock.unlock();
            }
        }).start();
        // 写入操作示例
        new Thread(() -> {
            RLock writeLock = rwLock.writeLock();
            try {
                // 获取写锁
                writeLock.lock();
                // 执行写入操作
                System.out.println("Write operation started");
                // 模拟写入操作耗时
                TimeUnit.SECONDS.sleep(2);
                System.out.println("Write operation completed");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                // 释放写锁
                writeLock.unlock();
            }
        }).start();
    }
}

import org.redisson.Redisson;
import org.redisson.api.RCountDownLatch;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
public class RedissonCountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        // 配置Redisson客户端
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        // 创建Redisson客户端
        RedissonClient redissonClient = Redisson.create(config);
        // 创建一个计数为3的闭锁
        RCountDownLatch latch = redissonClient.getCountDownLatch("myCountDownLatch");
        latch.trySetCount(3);
        // 启动三个线程，每个线程在完成工作时减少闭锁的计数
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    // 模拟工作耗时
                    Thread.sleep((long) (Math.random() * 1000));
                    System.out.println(Thread.currentThread().getName() + " - Work done, count down.");
                    // 减少闭锁的计数
                    latch.countDown();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }).start();
        }
        // 等待直到闭锁的计数达到0
        System.out.println("Main thread - Waiting for all threads to complete.");
        latch.await();
        System.out.println("Main thread - All threads have completed.");
        // 关闭Redisson客户端
        redissonClient.shutdown();
    }
}

redis> MULTI
  OK
  redis> SET msg "other msg"
  QUEUED
  redis> wrongcommand  ### 故意写错误的命令
  (error) ERR unknown command 'wrongcommand' 
  redis> EXEC
  (error) EXECABORT Transaction discarded because of previous errors.
  redis> GET msg
  "hello world"

redis> MULTI  
  OK
  redis> SET msg "other msg"
  QUEUED
  redis> SET mystring "I am a string"
  QUEUED
  redis> HMSET mystring name  "test"
  QUEUED
  redis> SET msg "after"
  QUEUED
  redis> EXEC
  1) OK
  2) OK
  3) (error) WRONGTYPE Operation against a key holding the wrong kind of value
  4) OK
  redis> GET msg
  "after"

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.WatchMonitor;
public class RedisWatchExample {
    public static void main(String[] args) {
        // 连接到Redis服务器
        Jedis jedis = new Jedis("localhost", 6379);
        // 要监视的键
        String watchedKey = "myKey";
        // 初始值设置（仅用于示例初始化）
        jedis.set(watchedKey, "initialValue");
        while (true) {
            try (WatchMonitor monitor = jedis.watch(watchedKey)) {
                // 开始事务
                Transaction tx = jedis.multi();
                // 获取当前值（注意：这个值在EXEC之前可能是过时的，如果其他客户端修改了它）
                String currentValue = jedis.get(watchedKey);
                System.out.println("Current value before transaction: " + currentValue);
                // 假设我们要在值后面追加一些内容
                String newValue = currentValue + "_appended";
                // 在事务中设置新值
                tx.set(watchedKey, newValue);
                // 尝试执行事务
                tx.exec();
                System.out.println("Transaction succeeded, new value set to: " + newValue);
                break; // 如果事务成功，跳出循环
            } catch (Exception e) {
                // 如果捕获到异常（通常是jedis.exceptions.JedisDataException: WATCHED KEY MODIFIED），表示事务期间键被修改
                System.out.println("Transaction failed due to watched key being modified. Retrying...");
                // 这里可以选择重试或者其他错误处理逻辑
            }
            // 注意：在try-with-resources语句中，monitor会自动unwatch，但在catch块中退出循环时不会执行到那里。
            // 在实际应用中，你可能需要在finally块中显式调用jedis.unwatch()以确保资源释放，但在这个简单示例中不是必需的。
            // 因为jedis连接在整个main方法期间都保持打开状态，并且我们在每次循环迭代开始时都会重新调用watch。
        }
        // 关闭Jedis连接
        jedis.close();
    }
}