您可以将令牌放在AtomicReference中，然后使用Semaphore暂停线程：

public class TokenWrapper {
  private final AtomicReference<Token> tokenRef = new AtomicReference<>(null);
  private final Semaphore semaphore = new Semaphore(Integer.MAX_VALUE);

  public TokenWrapper() {
    Token newToken = // refresh token
    tokenRef.set(newToken);
  }

  public Token getToken() {
    Token token = null;
    while((token = tokenRef.get()) == null) {
      semaphore.acquire();
    }
    return token;
  }

  public Token refreshToken(Token oldToken) {
    if(tokenRef.compareAndSet(oldToken, null)) {
      semaphore.drainPermits();          
      Token newToken = // refresh token
      tokenRef.set(newToken);
      semaphore.release(Integer.MAX_VALUE);
      return newToken;
    } else return getToken();
  }
}

public class RESTService {
  private static final TokenWrapper tokenWrapper = new TokenWrapper();

  public void run() {
    Token token = tokenWrapper.getToken();
    Response response = // call service with token
    if(response.getStatus == 401) {
      tokenWrapper.refreshToken(token);
    }
  }
}

X1 M0 N1 X在X1 M2 N1 X上使用原子X1 M1 N1 X以确保只有一个线程将刷新令牌，然后在X1 M4 N1 X上调用X1 M3 N1 X以使其它线程等待直到令牌被刷新。X1 M5 N1 X如果令牌不是X1 M6 N1 X则返回令牌，else在semaphore上等待-这是在循环中完成的，因为线程可能必须在tokenRef被设置为null和drainPermits()在semaphore上被调用之间旋转几个周期。
编辑：修改了refreshToken(Token oldToken)的签名，以便传入旧令牌，而不是在方法内部读取-这是为了防止出现以下情况：RESTService_A刷新令牌，RESTService_B使用旧的过期令牌获得401，然后RESTService_B在RESTService_A完成对refreshToken的调用后调用refreshToken，使用新的签名，RESTService_B将传入旧的过期令牌，因此当旧令牌无法匹配新令牌时，compareAndSet调用将失败，从而导致refreshToken仅被调用一次。

您可以使用以下模式，仅使用getter访问令牌，并在收到错误响应时调用loadToken。

class TokenGenerator {
    private String token = null;
    public synchronized String getToken() {
        if (token == null) {
            loadToken();
        }
        return token;
    }
    public synchronized void loadToken() {
        token = "load here";
    }           
}

要解决暂停线程的问题，您可以在任何需要暂停getToken()的地方调用getToken()，Thread将在加载令牌当前处于活动状态时自动阻塞。

class Task implements Runnable{
    private String name;
    private TokenGenerator tokenGenerator;

    public Task(String name, TokenGenerator tokenGenerator) {
        this.name = name;
        this.tokenGenerator = tokenGenerator;
    }

    @Override
    public void run() {
        getResponse(tokenGenerator.getToken());
    }

    private void getResponse(String token) {
        // Make http calls
        // if token expire , call getToken again. Pause all the running threads , and
        // update the token for all threads

        tokenGenerator.loadToken();
    }
}

因为你需要做两件事（http调用和更新令牌），你可以尝试双向检查。
一个用于检查令牌是否为is expired or not，另一个用于检查是否有任何其它线程正在尝试update the token。
这里有一个小代码来演示这个想法（它的方式有点脏，所以可能需要一些清理）

...
private string token
private volatile static isTokenExpired=false   //checking if the token is expired or not
private volatile static waitingForTokenRefresher=false;  //checking if we should wait for update.

@Override
public void run(){
  while(tokenisExpired){
      //wait
  }

  //http calls find out if token is good to go
  //check if no one else uses the token:
  if( token is actually expired){
   if(!waitingForTokenRefresher){
       isTokenExpired=true;
       waitingForTokenRefresher=true;
       //refresh token
       waitingForTokenRefresher=false
       isTokenExpired=false;
   }
  }
   while(!waitingForTokenRefresher){
     //wait...
   }

}