Spring Webflux concurrent access to shared resource

I'm trying to implement a service that call to external API. There are two types of requests:
client.authorize() acquires a new token with lifetime 1 hour, client.performRequest(..) gets some data from API, requires authorization token acquired by client.authorize() request. Client class utilizes Spring Reactive WebClient.
Is it ok, to use ReentrantLock for synchronizing a block of code that checks and refreshes token if it's not fresh? Or it breaks reactive model? Maybe there are more convinient ways to organize access to common resource in reactive programming?

@Service
@RequiredArgsConstructor
public class Service {

    private final Client client;

    @Setter(AccessLevel.NONE)
    private Lock authLock = new ReentrantLock();
    @Setter(AccessLevel.NONE)
    private String authToken;
    @Setter(AccessLevel.NONE)
    private LocalDateTime tokenExpirationDatetime;

    public Mono<Response> performRequest(Request request) {
        return preAuthorize()
                .flatMap(token -> client.performRequest(request, token));
    }

    private Mono<String> preAuthorize() {
        authLock.lock();
        try {
            if (existsActualToken()) {
                return Mono.just(authToken);
            }
            return refreshToken();
        } finally {
            authLock.unlock();
        }
    }

    private boolean existsActualToken() {
        return authToken != null
                && tokenExpirationDatetime.isAfter(LocalDateTime.now());
    }

    private Mono<String> refreshToken() {
        return client.authorize()
                .doOnNext(response -> {
                    this.authToken = response.token();
                    this.tokenExpirationDatetime = response.expirationDatetime();
                })
                .map(Response::token);
    }
}

As a caching alternative, Spring-webflux contains an instance method in Mono to provide a simple cache with Mono<T> cache(Duration ttl).

To use this, you must ensure that you are using the same instance of Mono<T> for each retrivement of the cached value to actually use the cache. There are several ways to achieve this, but perhaps the most practical way is through configuring a bean for the Mono which fetches the token. A small application which applies this:

Test.java:

@SpringBootApplication
public class Test {
public static void main(String[] args) {
SpringApplication.run(Test.class, args);
}
}
@Component
@RequiredArgsConstructor
class Runner {
private final Mono<String> auth;
@EventListener(ApplicationReadyEvent.class)
public void run() {
Flux.<Request>generate(sink -> sink.next(new Request()))
.flatMap(request -> auth.map(request::setAuth))
.delayElements(Duration.ofSeconds(1))
.doOnNext(request -> System.out.println("created request with auth: %s".formatted(request.getAuth())))
.collectList()
.block();
}
}
@Data
class Request {
String auth;
}
@RestController
class Controller {
@GetMapping("/token")
public Mono<String> createAuth() {
return Mono.just("auth")
.doOnNext(x -> System.out.println("created auth"));
}
}
@Configuration
class Config {
@Bean
public WebClient webClient(WebClient.Builder webClientBuilder) {
return webClientBuilder.build();
}
@Bean
public Mono<String> auth(WebClient webClient) {
return webClient.get()
.uri("http://localhost:8080/token")
.retrieve().bodyToMono(String.class)
.cache(Duration.ofSeconds(10));
}
}