1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.curator.stats;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
/**
* Information about a lock.
*
* <p>Should be mutated by a single thread, except {@link #fillStackTrace()} which can be
* invoked by any threads. Other threads may see an inconsistent state of this instance.</p>
*
* @author hakon
*/
public class LockAttempt {
private final ThreadLockStats threadLockStats;
private final String lockPath;
private final Instant callAcquireInstant;
private final Duration timeout;
private final boolean reentry;
private final LockMetrics lockMetrics;
private final List<LockAttempt> nestedLockAttempts = new ArrayList<>();
private final LatencyStats.ActiveInterval activeAcquireInterval;
// Only accessed by mutating thread:
private Optional<LatencyStats.ActiveInterval> activeLockedInterval = Optional.empty();
private volatile Optional<Instant> lockAcquiredInstant = Optional.empty();
private volatile Optional<Instant> terminalStateInstant = Optional.empty();
private volatile Optional<String> stackTrace = Optional.empty();
public enum LockState {
ACQUIRING(false), ACQUIRE_FAILED(true), TIMED_OUT(true), ACQUIRED(false), RELEASED(true),
RELEASED_WITH_ERROR(true);
private final boolean terminal;
LockState(boolean terminal) { this.terminal = terminal; }
public boolean isTerminal() { return terminal; }
}
private volatile LockState lockState = LockState.ACQUIRING;
public static LockAttempt invokingAcquire(ThreadLockStats threadLockStats, String lockPath,
Duration timeout, LockMetrics lockMetrics,
boolean reentry) {
return new LockAttempt(threadLockStats, lockPath, timeout, Instant.now(), lockMetrics, reentry);
}
private LockAttempt(ThreadLockStats threadLockStats, String lockPath, Duration timeout,
Instant callAcquireInstant, LockMetrics lockMetrics, boolean reentry) {
this.threadLockStats = threadLockStats;
this.lockPath = lockPath;
this.callAcquireInstant = callAcquireInstant;
this.timeout = timeout;
this.lockMetrics = lockMetrics;
this.reentry = reentry;
this.activeAcquireInterval = lockMetrics.acquireInvoked(reentry);
}
public String getThreadName() { return threadLockStats.getThreadName(); }
public String getLockPath() { return lockPath; }
public Instant getTimeAcquiredWasInvoked() { return callAcquireInstant; }
public Duration getAcquireTimeout() { return timeout; }
public boolean isReentry() { return reentry; }
public LockState getLockState() { return lockState; }
public Optional<Instant> getTimeLockWasAcquired() { return lockAcquiredInstant; }
public boolean isAcquiring() { return lockAcquiredInstant.isEmpty(); }
public Instant getTimeAcquireEndedOrNow() {
return lockAcquiredInstant.orElseGet(() -> getTimeTerminalStateWasReached().orElseGet(Instant::now));
}
public Optional<Instant> getTimeTerminalStateWasReached() { return terminalStateInstant; }
public Optional<String> getStackTrace() { return stackTrace; }
public List<LockAttempt> getNestedLockAttempts() { return List.copyOf(nestedLockAttempts); }
public Duration getDurationOfAcquire() { return Duration.between(callAcquireInstant, getTimeAcquireEndedOrNow()); }
public Duration getDurationWithLock() {
return lockAcquiredInstant
.map(start -> Duration.between(start, terminalStateInstant.orElseGet(Instant::now)))
.orElse(Duration.ZERO);
}
public Duration getDuration() { return Duration.between(callAcquireInstant, terminalStateInstant.orElseGet(Instant::now)); }
/** Get time from just before trying to acquire lock to the time the terminal state was reached, or ZERO. */
public Duration getStableTotalDuration() {
return terminalStateInstant.map(instant -> Duration.between(callAcquireInstant, instant)).orElse(Duration.ZERO);
}
/** Fill in the stack trace starting at the caller's stack frame. */
public void fillStackTrace() {
// This method is public. If invoked concurrently, the this.stackTrace may be updated twice,
// which is fine.
this.stackTrace = Optional.of(threadLockStats.getStackTrace());
}
void addNestedLockAttempt(LockAttempt nestedLockAttempt) {
nestedLockAttempts.add(nestedLockAttempt);
}
void acquireFailed() {
setTerminalState(LockState.ACQUIRE_FAILED);
lockMetrics.acquireFailed(reentry, activeAcquireInterval);
}
void timedOut() {
setTerminalState(LockState.TIMED_OUT);
lockMetrics.acquireTimedOut(reentry, activeAcquireInterval);
}
void lockAcquired() {
lockState = LockState.ACQUIRED;
lockAcquiredInstant = Optional.of(Instant.now());
activeLockedInterval = Optional.of(lockMetrics.lockAcquired(reentry, activeAcquireInterval));
}
void preRelease() {
lockMetrics.preRelease(reentry, activeLockedInterval.orElseThrow());
}
void postRelease() {
setTerminalState(LockState.RELEASED);
}
void releaseFailed() {
setTerminalState(LockState.RELEASED_WITH_ERROR);
lockMetrics.releaseFailed(reentry);
}
void setTerminalState(LockState terminalState) { setTerminalState(terminalState, Instant.now()); }
void setTerminalState(LockState terminalState, Instant instant) {
lockState = terminalState;
terminalStateInstant = Optional.of(instant);
}
}
|
