class ConcurrentHashMap<K, V> {
    final Segment[] segments;
    class Segment extends ReentrantLock implements Serializable{
        // 每個 Segment 自己獨立的哈希表
        private final Map<K,V> map = new HashMap<>();
        // Segment 內(nèi)部加鎖機制，確保線程安全
        public synchronized V put(K key, V value) {
            return map.put(key, value);
        }
    }
    // 獲取 key 所屬的 Segment 的索引
    private int getSegmentIndex(K key) {
        int hash = hash(key.hashCode()); // 對 hashcode() 進行哈希
        int segmentMask = segments.length - 1; // mask 值
        return hash & segmentMask; // 按位與，定位具體的 Segment
    }
    public V put(K key, V value) {
        Segment s = segments[getSegmentIndex(key)];
        s.lock(); // 獲取 s 對應的 Segment 的鎖
        try {
            return s.put(key, value); // 在 s 上進行 put 操作
        } finally {
            s.unlock(); // 釋放 s 對應的 Segment 的鎖
        }
    }
}

import java.util.concurrent.ConcurrentHashMap;
public class Counter {
    private final ConcurrentHashMap<String, Integer> map;
    public Counter() {
        this.map = new ConcurrentHashMap<>();
    }
    public void increase(String key) {
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }
    public int get(String key) {
        return map.getOrDefault(key, 0);
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class TaskManager {
    private final ConcurrentHashMap<String, TaskInfo> tasks;
    public TaskManager() {
        this.tasks = new ConcurrentHashMap<>();
    }
    public void addTask(String taskId, Runnable task) {
        // 添加任務信息
        tasks.put(taskId, new TaskInfo());
        // 提交任務到線程池
        ExecutorService executor = Executors.newCachedThreadPool();
        executor.submit(() -> {
            try {
                // 執(zhí)行任務
                task.run();
                // 更新任務狀態(tài)和結(jié)果
                TaskInfo info = tasks.get(taskId);
                info.setStatus(TaskStatus.COMPLETED);
                info.setResult("Task completed successfully!");
            } catch (Exception ex) {
                // 更新任務狀態(tài)和結(jié)果
                TaskInfo info = tasks.get(taskId);
                info.setStatus(TaskStatus.FAILED);
                info.setResult(ex.getMessage());
            }
        });
        // 關閉線程池
        executor.shutdown();
    }
    public TaskInfo getTaskInfo(String taskId) {
        return tasks.getOrDefault(taskId, new TaskInfo());
    }
}
enum TaskStatus {
    NEW,
    RUNNING,
    COMPLETED,
    FAILED;
}
class TaskInfo {
    private TaskStatus status;
    private String result;
    public TaskInfo() {
        this.status = TaskStatus.NEW;
        this.result = "";
    }
    public TaskStatus getStatus() {
        return status;
    }
    public void setStatus(TaskStatus status) {
        this.status = status;
    }
    public String getResult() {
        return result;
    }
    public void setResult(String result) {
        this.result = result;
    }
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CacheManager<K, V> {
    private final Map<K, CacheEntry<V>> cache;
    public CacheManager() {
        this.cache = new ConcurrentHashMap<>();
    }
    public void put(K key, V value, long ttl) {
        // 添加緩存項，同時記錄當前時間戳和緩存生存時間
        CacheEntry<V> entry = new CacheEntry<>(value, System.currentTimeMillis(), ttl);
        cache.put(key, entry);
    }
    public V get(K key) {
        // 獲取緩存項和其緩存生存時間
        CacheEntry<V> entry = cache.get(key);
        // 檢查緩存項是否過期，如果過期則刪除緩存項并返回 null
        if (entry != null && !entry.isExpired()) {
            return entry.getValue();
        } else {
            cache.remove(key);
            return null;
        }
    }
    static class CacheEntry<V> {
        private final V value;
        private final long timestamp;
        private final long ttl;
        public CacheEntry(V value, long timestamp, long ttl) {
            this.value = value;
            this.timestamp = timestamp;
            this.ttl = ttl;
        }
        public V getValue() {
            return value;
        }
        public boolean isExpired() {
            return System.currentTimeMillis() - timestamp > ttl;
        }
    }
}