public static class APIRedisHelper
 {
     #region 私有成员
     // 连接字符串（保持你的原逻辑）
     private static readonly Lazy<ConnectionMultiplexer?> _connLazy = new(() =>
     {
         try
         {
             return ConnectionMultiplexer.Connect(GetConnectionString());
         }
         catch
         {
             // 首次连接失败后先返回 null
             return null;
         }
     });

     // volatile 保证可见性；用于重连后替换实例
     private static volatile ConnectionMultiplexer? _current;
     private static readonly SemaphoreSlim _lock = new(1, 1);

     private static IDatabase? Db => _current?.GetDatabase() ?? _connLazy.Value?.GetDatabase();

     public static TimeSpan ExpireTime = TimeSpan.FromDays(60);

     private static string? GetConnectionString()
     {
         return new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json")
                .Build()["Connection:APIRedisConnectionString"]?.Trim();
     }

     /// <summary>
     /// 获取当前可用的 Database 实例，如果已断开则尝试重连一次。
     /// 整个重连过程是异步的，但调用方不会阻塞（快速失败）。
     /// </summary>
     private static async Task<IDatabase?> GetDbAsync()
     {
         var old = _current ?? _connLazy.Value;
         if (old is null || !old.IsConnected)
         {
             // 双重检查锁，确保只会有一个线程去重连
             await _lock.WaitAsync().ConfigureAwait(false);
             try
             {
                 // 再次判断，防止并发重连
                 var again = _current ?? _connLazy.Value;
                 if (again is null || !again.IsConnected)
                 {
                     again?.Dispose(); // 释放旧连接
                     try
                     {
                         var mux = await ConnectionMultiplexer.ConnectAsync(GetConnectionString()).ConfigureAwait(false);
                         _current = mux; // 覆盖实例
                     }
                     catch (Exception ex)
                     {
                         // 记录日志后仍返回 null（保持你的异常处理风格）
                         NLogHelper.WriteError($"Redis 重连失败: {ex.Message}-{ex.StackTrace}");
                         _current = null;
                     }
                 }
             }
             finally
             {
                 _lock.Release();
             }
         }
         return (_current ?? _connLazy.Value)?.GetDatabase();
     }

     private static async Task<T> SafeExecuteAsync<T>(Func<IDatabase, Task<T>> redisFunc, T defaultValue = default!)
     {
         try
         {
             var db = await GetDbAsync().ConfigureAwait(false);
             return db is null ? defaultValue : await redisFunc(db).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
             NLogHelper.WriteError($"Redis操作失败: {ex.Message}-{ex.StackTrace}");
             return defaultValue;
         }
     }

     private static T SafeExecute<T>(Func<IDatabase, T> redisFunc, T defaultValue = default!)
     {
         try
         {
             return Db is null ? defaultValue : redisFunc(Db);
         }
         catch (Exception ex)
         {
             NLogHelper.WriteError($"Redis操作失败: {ex.Message}-{ex.StackTrace}");
             return defaultValue;
         }
     }
     #endregion

     #region 部分Key 命名
     public static string GetHTMKey(string key) => $"htm_{key}";
     public static string GetHTCKey(string key) => $"htc_{key}";
     public static string GetHTPKey(string key) => $"htp_{key}";
     public static string GetHTBKey(string key) => $"htb_{key}";
     #endregion

     #region 基础方法
     public static Task<bool> SetAsync(string key, string value, TimeSpan? expiry = null) =>
         SafeExecuteAsync(db => db.StringSetAsync(key, value, expiry ?? ExpireTime), false);

     public static Task<string?> GetAsync(string key) =>
         SafeExecuteAsync(async db => (string?)await db.StringGetAsync(key));

     public static Task<bool> DeleteAsync(string key) =>
         SafeExecuteAsync(db => db.KeyDeleteAsync(key), false);

     public static Task<bool> ExistsAsync(string key) =>
         SafeExecuteAsync(db => db.KeyExistsAsync(key), false);

     public static Task<bool> SetExpiryAsync(string key, TimeSpan expiry) =>
         SafeExecuteAsync(db => db.KeyExpireAsync(key, expiry), false);
     #endregion
 }

        private async Task<KiaserData> GetKiaserData(string addr)
        {
            try
            {
                var data = await APIRedisHelper.GetAsync($"{APIRedisHelper.GetHTMKey(addr)}");
                if (data == null)
                {
                    string str = GetKiaserData(addr);
                    var redis = GetHTMObject(str);
                    if (redis != null)
                    {
                        var task = Task.Factory.StartNew(async () =>
                        {
                            redis.Addr = addr;
                            await APIRedisHelper.SetAsync($"{APIRedisHelper.GetHTMKey(addr)}", JsonConvert.SerializeObject(redis));
                        });
                    }

                    return redis;
                }
                return JsonConvert.DeserializeObject<KiaserData>(data);
            }
            catch (Exception ex)
            {
                NLogHelper.WriteError($"获取Kiase数据请求异常,{addr}-{ex.Message}", ParamConst.KiaserHome);
            }
            return null;

        }