Design Thread-Safe Cache with TTL (medium)

Design a thread-safe cache whose entries expire after a time to live (TTL).

The cache receives a clock function in its constructor. Calling clock returns the current logical time in milliseconds. The judge controls this clock, so you should not read the system clock or create background cleanup threads.

Implement these operations:

put(key, value, ttlMillis) inserts or replaces a key. Its expiry time is clock() + ttlMillis.
get(key) returns the stored value when the key exists and has not expired. Otherwise, it removes an expired entry if necessary and returns -1.
size() removes all expired entries and returns the number of live entries.

An entry is expired when the current time is greater than or equal to its expiry time. All three methods may be called concurrently on the same cache instance.

The judge creates the cache, supplies the logical clock, and starts all worker threads. Your implementation should provide only the cache state and synchronization.

The judge also preloads the standard concurrency, callback, and collection APIs for each supported language. You do not need to add import, include, or using statements.

Example 1:

Input:

Output:

Explanation: The entry expires at logical time 100 + 50 = 150. It is live at time 149 and expired at time 150.

Example 2:

Input:

Output:

Explanation: Replacing key 7 installs both the new value and the new expiry time. The old expiry at time 15 must not remove the replacement.

Constraints

0 <= key <= 1_000_000
0 <= value <= 1_000_000
1 <= ttlMillis <= 1_000_000
The logical clock is monotonic and returns a non-negative value.
At most 1_000 entries are live at once.
At most 20_000 method calls are made.
The value -1 is reserved to represent a cache miss.