Igyekeztem többet megtudni a szálak biztonságáról, és próbáltam a jó gyakorlatokra gondolni a szálbiztonsági kód implementálásakor. A token lekérésével összefüggésben szeretném nyomon követni az aktuális időt, és azt az időpontot, amikor a token lejár (felezve, így a token lejárta előtt frissítek). Íme néhány pszeudo kód arra a helyzetre, amelyen gondolkodom
long renewTime = 0; //should this be a volatile long?
Lock lock = new Lock
Service someService = new Service();
public void authenticateWithSomeService() {
try {
lock.get()
//...call to login with someService
renewTime = System.currentTimeMillis() + someService.getToken.getExpirationTime/2
catch (Exception e) {
//log or rethrow
} finally {
lock.unlock();
}
}
private void refreshToken() {
if(System.currentTimeMillis() > renewTime) {
//...call to renew token with someService
long newTime = someService.getToken.getExpirationTime/2
renewTime = System.currentTimeMillis() + newTime;
}
}
public synchronized String getStuff() {
refreshToken(); //check if token needs to be refreshed
try {
//...some HTTP call to get an item with the service
} catch (Exception e) {
//log or rethrow
}
}
Tehát egy ilyen forgatókönyv esetén garantált-e, hogy a renewTime-t mindig csak egy szál fogja olvasni/írni, mivel 1. a hitelesítési módszer zárakat használ, és 2. a getStuff metódus, amely a renewTime-t olvassa és írja, szinkronizálva van? Biztonságos ez a szál, vagy a renewTime-nek illékonynak kell lennie, hogy a szálak ugyanazt az értéket érjék el?
