"刷新雪崩"(即多个并发请求同时触发 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) 是最优雅且性能最好的选择;如果项目结构简单,方案一(锁机制) 也是完全可接受的稳健方案。