Java:“刷新雪崩”

"刷新雪崩"(即多个并发请求同时触发 Token 刷新)与并发安全问题,确保同一时刻只有一个线程执行刷新操作,其他线程等待刷新完成后直接使用新 Token 重试‌。

方案一:使用 ReentrantLock + volatile 标志位(推荐轻量级场景)

这是最常用且易于理解的方案。通过一个全局锁和一个状态标志位,确保只有第一个发现 Token 过期的线程去执行刷新,其他线程阻塞等待或稍后重试。

全局锁‌:使用 ReentrantLock 保证刷新操作的互斥性。

状态标记‌:使用 volatile boolean isRefreshing 标记当前是否正在刷新。

双重检查‌:在获取锁前后检查状态,避免不必要的锁竞争。

代码实现:

import java.util.concurrent.locks.ReentrantLock;

public class TokenManager {

private volatile String accessToken = "initial_token";

private volatile boolean isRefreshing = false;

private final ReentrantLock refreshLock = new ReentrantLock();

/**

* 获取有效的 Access Token,如果过期则自动刷新

*/

public String getValidToken() {

// 1. 快速检查:如果 Token 有效且未在刷新,直接返回

if (!isTokenExpired(accessToken) && !isRefreshing) {

return accessToken;

}

// 2. 尝试获取锁进行刷新

refreshLock.lock();

try {

// 3. 双重检查:防止在等待锁的过程中,其他线程已经刷新成功

if (isRefreshing) {

// 如果正在刷新,当前线程可以等待刷新完成(简化版可直接返回旧Token让调用方重试,或等待)

// 这里采用等待策略:自旋等待直到刷新完成

while (isRefreshing) {

try { Thread.sleep(10); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }

}

return accessToken;

}

// 4. 执行刷新

isRefreshing = true;

try {

String newToken = refreshAccessTokenFromServer(); // 调用远程接口刷新

this.accessToken = newToken;

} finally {

isRefreshing = false;

}

} finally {

refreshLock.unlock();

}

return accessToken;

}

private boolean isTokenExpired(String token) {

// 实际项目中解析 JWT 或检查缓存时间

return false;

}

private String refreshAccessTokenFromServer() {

// 模拟网络请求

return "new_token_" + System.currentTimeMillis();

}

}

注意‌:上述代码中的"自旋等待"在高并发下可能消耗 CPU。更优雅的方式是让未获得锁的线程抛出特定异常,由上层统一重试,或者使用 CompletableFuture 异步等待(见方案三)。

方案二:使用 CompletableFuture 实现异步编排(推荐高并发场景)

参考现代 Java 开发实践,利用 CompletableFuture 可以将"刷新 Token"作为一个异步任务,所有因 401 失败的请求都依赖这个未来的结果。这样既避免了线程阻塞,又保证了只刷新一次。

核心优势

非阻塞‌:等待刷新的线程不会占用业务线程池资源。

结果共享‌:所有等待的请求共享同一个 CompletableFuture<String> 结果。

代码实现思路

import java.util.concurrent.CompletableFuture;

import java.util.concurrent.locks.ReentrantLock;

public class AsyncTokenManager {

private volatile String accessToken = "initial_token";

private volatile CompletableFuture<String> refreshFuture = null;

private final ReentrantLock lock = new ReentrantLock();

public String getTokenSync() {

// 同步获取,内部可能触发异步刷新

try {

return getValidTokenAsync().get(); // 阻塞等待结果

} catch (Exception e) {

throw new RuntimeException("Failed to get token", e);

}

}

public CompletableFuture<String> getValidTokenAsync() {

if (!isTokenExpired(accessToken)) {

return CompletableFuture.completedFuture(accessToken);

}

lock.lock();

try {

// 如果已经有正在进行的刷新任务,直接返回该任务

if (refreshFuture != null && !refreshFuture.isDone()) {

return refreshFuture;

}

// 创建新的刷新任务

refreshFuture = CompletableFuture.supplyAsync(this::refreshAccessTokenFromServer)

.whenComplete((newToken, ex) -> {

if (ex == null) {

this.accessToken = newToken;

}

// 清除引用,允许下一次刷新

lock.lock();

try {

if (this.refreshFuture == refreshFuture) {

this.refreshFuture = null;

}

} finally {

lock.unlock();

}

});

return refreshFuture;

} finally {

lock.unlock();

}

}

private String refreshAccessTokenFromServer() {

// 模拟耗时操作

try { Thread.sleep(1000); } catch (InterruptedException e) {}

return "new_async_token_" + System.currentTimeMillis();

}

private boolean isTokenExpired(String token) {

return true; // 模拟过期

}

}

方案三:前端/客户端侧的"Promise 锁"模式

如果是前端或移动端开发,原理相同,但实现更简洁。核心是‌用一个全局 Promise 变量来缓存刷新请求‌。

逻辑描述

定义一个全局变量 refreshPromise。

当请求拦截器捕获到 401 时:

如果 refreshPromise 为空,创建一个新的 Promise 执行刷新操作,并赋值给 refreshPromise。

如果 refreshPromise 已存在(说明其他请求正在刷新),直接 await 这个 Promise。

刷新完成后,将 refreshPromise 重置为 null,并返回新 Token。

所有等待的请求拿到新 Token 后,重新发起原始请求。

伪代码示例(JavaScript/TypeScript 风格,便于理解逻辑)

typescript

let refreshPromise: Promise<string> | null = null;

async function getValidToken(): Promise<string> {

if (isTokenValid(currentToken)) {

return currentToken;

}

// 如果正在刷新,等待现有的刷新过程

if (refreshPromise) {

return refreshPromise;

}

// 启动新的刷新过程

refreshPromise = new Promise(async (resolve, reject) => {

try {

const newToken = await api.refreshToken(); // 调用刷新接口

currentToken = newToken;

resolve(newToken);

} catch (error) {

reject(error);

} finally {

refreshPromise = null; // 重置,允许下次刷新

}

});

return refreshPromise;

}

关键注意事项

Refresh Token 的安全性‌:

Refresh Token 是高权限凭证,必须安全存储(后端加密存储,前端 HttpOnly Cookie 或安全存储区)。

遵循 OAuth 2.1 最佳实践,Refresh Token 应支持‌轮换(Rotation)‌,即每次使用后颁发新的 Refresh Token,旧的立即失效,防止重放攻击。

避免无限重试‌:

如果刷新 Token 本身也返回 401(说明 Refresh Token 也过期了),应直接终止重试,引导用户重新登录。

设置最大重试次数(如 1 次刷新机会)。

时间同步问题‌:

不要完全依赖本地时间判断 Token 是否过期,因为客户端时间可能不准。建议预留一定的"缓冲时间"(如提前 5 分钟刷新),或在收到 401 后再触发刷新。

线程池隔离‌:

如果使用异步方案,建议使用独立的线程池执行刷新任务,避免阻塞主业务线程池。

|------------|--------------------------|--------------|------------------|
| 场景 | 推荐方案 | 优点 | 缺点 |
| ‌传统同步阻塞服务‌ | ReentrantLock + volatile | 实现简单,逻辑直观 | 高并发下等待线程会阻塞,占用资源 |
| ‌高并发异步服务‌ | CompletableFuture | 非阻塞,性能好,结果共享 | 代码复杂度稍高,需处理异步异常 |
| ‌前端/移动端‌ | 全局 Promise 缓存 | 天然适配异步模型,简洁 | 仅适用于单线程事件循环环境 |

对于大多数 Java 后端微服务架构,‌方案二(CompletableFuture)‌ 是最优雅且性能最好的选择;如果项目结构简单,‌方案一(锁机制)‌ 也是完全可接受的稳健方案。

相关推荐
郝学胜-神的一滴14 分钟前
Effective STL 条款03:容器中的对象复制要廉价且正确
开发语言·数据结构·c++·算法·rpc·stl
秋天的怀念_David15 分钟前
算法一千零一夜 · 第三十三夜 · 跳表
java·程序人生·算法
西西弗Sisyphus1 小时前
C++ explicit 关键字工程实践
开发语言·c++
Forget the Dream2 小时前
Spring AI 2.0 系列(二):第一个 ChatClient——从注入到一次完整调用
java·人工智能·spring boot·ai·springai
郝学胜-神的一滴3 小时前
Effective Python 条款35:用类封装替代生成器异常注入
开发语言·人工智能·python·金融·pandas·scikit-learn·matplotlib
feixing_fx3 小时前
原始类型与引用类型:赋值时到底复制了什么
开发语言·前端·javascript·前端框架
wuyk5553 小时前
Python办公自动化-第02讲-Excel文件认知与四大库选型
开发语言·python·excel
黑十4 小时前
FDE 怎么快速搭一个可演示页面?最小前端方案
java·大数据·前端·数据库·人工智能
神明不懂浪漫4 小时前
【第八章】多线程(一)
java·开发语言·经验分享·笔记